]> git.ipfire.org Git - thirdparty/glibc.git/blob - math/libm-test.inc
projects / thirdparty / glibc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix pow of negative numbers to integer exponents (bugs 369, 2678, 3866).
[thirdparty/glibc.git] / math / libm-test.inc
1 /* Copyright (C) 1997-2006, 2007, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Andreas Jaeger <aj@suse.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 Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the 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 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19 /* Part of testsuite for libm.
20
21 This file is processed by a perl script. The resulting file has to
22 be included by a master file that defines:
23
24 Macros:
25 FUNC(function): converts general function name (like cos) to
26 name with correct suffix (e.g. cosl or cosf)
27 MATHCONST(x): like FUNC but for constants (e.g convert 0.0 to 0.0L)
28 FLOAT: floating point type to test
29 - TEST_MSG: informal message to be displayed
30 CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
31 chooses one of the parameters as delta for testing
32 equality
33 PRINTF_EXPR Floating point conversion specification to print a variable
34 of type FLOAT with printf. PRINTF_EXPR just contains
35 the specifier, not the percent and width arguments,
36 e.g. "f".
37 PRINTF_XEXPR Like PRINTF_EXPR, but print in hexadecimal format.
38 PRINTF_NEXPR Like PRINTF_EXPR, but print nice. */
39
40 /* This testsuite has currently tests for:
41 acos, acosh, asin, asinh, atan, atan2, atanh,
42 cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
43 fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
44 frexp, gamma, hypot,
45 ilogb, isfinite, isinf, isnan, isnormal,
46 isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
47 j0, j1, jn,
48 ldexp, lgamma, log, log10, log1p, log2, logb,
49 modf, nearbyint, nextafter,
50 pow, remainder, remquo, rint, lrint, llrint,
51 round, lround, llround,
52 scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
53 y0, y1, yn, significand
54
55 and for the following complex math functions:
56 cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
57 ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.
58
59 At the moment the following functions aren't tested:
60 drem, nan
61
62 Parameter handling is primitive in the moment:
63 --verbose=[0..3] for different levels of output:
64 0: only error count
65 1: basic report on failed tests (default)
66 2: full report on all tests
67 -v for full output (equals --verbose=3)
68 -u for generation of an ULPs file
69 */
70
71 /* "Philosophy":
72
73 This suite tests some aspects of the correct implementation of
74 mathematical functions in libm. Some simple, specific parameters
75 are tested for correctness but there's no exhaustive
76 testing. Handling of specific inputs (e.g. infinity, not-a-number)
77 is also tested. Correct handling of exceptions is checked
78 against. These implemented tests should check all cases that are
79 specified in ISO C99.
80
81 Exception testing: At the moment only divide-by-zero, invalid and
82 overflow exceptions are tested. Underflow and inexact exceptions
83 aren't checked at the moment.
84
85 NaN values: There exist signalling and quiet NaNs. This implementation
86 only uses quiet NaN as parameter but does not differenciate
87 between the two kinds of NaNs as result.
88
89 Inline functions: Inlining functions should give an improvement in
90 speed - but not in precission. The inlined functions return
91 reasonable values for a reasonable range of input values. The
92 result is not necessarily correct for all values and exceptions are
93 not correctly raised in all cases. Problematic input and return
94 values are infinity, not-a-number and minus zero. This suite
95 therefore does not check these specific inputs and the exception
96 handling for inlined mathematical functions - just the "reasonable"
97 values are checked.
98
99 Beware: The tests might fail for any of the following reasons:
100 - Tests are wrong
101 - Functions are wrong
102 - Floating Point Unit not working properly
103 - Compiler has errors
104
105 With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
106
107
108 To Do: All parameter should be numbers that can be represented as
109 exact floating point values. Currently some values cannot be
110 represented exactly and therefore the result is not the expected
111 result. For this we will use 36 digits so that numbers can be
112 represented exactly. */
113
114 #ifndef _GNU_SOURCE
115 # define _GNU_SOURCE
116 #endif
117
118 #include "libm-test-ulps.h"
119 #include <complex.h>
120 #include <math.h>
121 #include <float.h>
122 #include <fenv.h>
123 #include <limits.h>
124
125 #include <errno.h>
126 #include <stdlib.h>
127 #include <stdio.h>
128 #include <string.h>
129 #include <argp.h>
130
131 /* Possible exceptions */
132 #define NO_EXCEPTION 0x0
133 #define INVALID_EXCEPTION 0x1
134 #define DIVIDE_BY_ZERO_EXCEPTION 0x2
135 #define OVERFLOW_EXCEPTION 0x4
136 /* The next flags signals that those exceptions are allowed but not required. */
137 #define INVALID_EXCEPTION_OK 0x8
138 #define DIVIDE_BY_ZERO_EXCEPTION_OK 0x10
139 #define OVERFLOW_EXCEPTION_OK 0x20
140 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
141 /* Some special test flags, passed togther with exceptions. */
142 #define IGNORE_ZERO_INF_SIGN 0x40
143
144 /* Various constants (we must supply them precalculated for accuracy). */
145 #define M_PI_6l .52359877559829887307710723054658383L
146 #define M_E2l 7.389056098930650227230427460575008L
147 #define M_E3l 20.085536923187667740928529654581719L
148 #define M_2_SQRT_PIl 3.5449077018110320545963349666822903L /* 2 sqrt (M_PIl) */
149 #define M_SQRT_PIl 1.7724538509055160272981674833411451L /* sqrt (M_PIl) */
150 #define M_LOG_SQRT_PIl 0.57236494292470008707171367567652933L /* log(sqrt(M_PIl)) */
151 #define M_LOG_2_SQRT_PIl 1.265512123484645396488945797134706L /* log(2*sqrt(M_PIl)) */
152 #define M_PI_34l (M_PIl - M_PI_4l) /* 3*pi/4 */
153 #define M_PI_34_LOG10El (M_PIl - M_PI_4l) * M_LOG10El
154 #define M_PI2_LOG10El M_PI_2l * M_LOG10El
155 #define M_PI4_LOG10El M_PI_4l * M_LOG10El
156 #define M_PI_LOG10El M_PIl * M_LOG10El
157 #define M_SQRT_2_2 0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
158
159 static FILE *ulps_file; /* File to document difference. */
160 static int output_ulps; /* Should ulps printed? */
161
162 static int noErrors; /* number of errors */
163 static int noTests; /* number of tests (without testing exceptions) */
164 static int noExcTests; /* number of tests for exception flags */
165 static int noXFails; /* number of expected failures. */
166 static int noXPasses; /* number of unexpected passes. */
167
168 static int verbose;
169 static int output_max_error; /* Should the maximal errors printed? */
170 static int output_points; /* Should the single function results printed? */
171 static int ignore_max_ulp; /* Should we ignore max_ulp? */
172
173 static FLOAT minus_zero, plus_zero;
174 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
175
176 static FLOAT max_error, real_max_error, imag_max_error;
177
178
179 #define BUILD_COMPLEX(real, imag) \
180 ({ __complex__ FLOAT __retval; \
181 __real__ __retval = (real); \
182 __imag__ __retval = (imag); \
183 __retval; })
184
185 #define BUILD_COMPLEX_INT(real, imag) \
186 ({ __complex__ int __retval; \
187 __real__ __retval = (real); \
188 __imag__ __retval = (imag); \
189 __retval; })
190
191
192 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1), \
193 (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
194
195 static void
196 init_max_error (void)
197 {
198 max_error = 0;
199 real_max_error = 0;
200 imag_max_error = 0;
201 feclearexcept (FE_ALL_EXCEPT);
202 }
203
204 static void
205 set_max_error (FLOAT current, FLOAT *curr_max_error)
206 {
207 if (current > *curr_max_error)
208 *curr_max_error = current;
209 }
210
211
212 /* Should the message print to screen? This depends on the verbose flag,
213 and the test status. */
214 static int
215 print_screen (int ok, int xfail)
216 {
217 if (output_points
218 && (verbose > 1
219 || (verbose == 1 && ok == xfail)))
220 return 1;
221 return 0;
222 }
223
224
225 /* Should the message print to screen? This depends on the verbose flag,
226 and the test status. */
227 static int
228 print_screen_max_error (int ok, int xfail)
229 {
230 if (output_max_error
231 && (verbose > 1
232 || ((verbose == 1) && (ok == xfail))))
233 return 1;
234 return 0;
235 }
236
237 /* Update statistic counters. */
238 static void
239 update_stats (int ok, int xfail)
240 {
241 ++noTests;
242 if (ok && xfail)
243 ++noXPasses;
244 else if (!ok && xfail)
245 ++noXFails;
246 else if (!ok && !xfail)
247 ++noErrors;
248 }
249
250 static void
251 print_ulps (const char *test_name, FLOAT ulp)
252 {
253 if (output_ulps)
254 {
255 fprintf (ulps_file, "Test \"%s\":\n", test_name);
256 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
257 CHOOSE("ldouble", "double", "float",
258 "ildouble", "idouble", "ifloat"),
259 FUNC(ceil) (ulp));
260 }
261 }
262
263 static void
264 print_function_ulps (const char *function_name, FLOAT ulp)
265 {
266 if (output_ulps)
267 {
268 fprintf (ulps_file, "Function: \"%s\":\n", function_name);
269 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
270 CHOOSE("ldouble", "double", "float",
271 "ildouble", "idouble", "ifloat"),
272 FUNC(ceil) (ulp));
273 }
274 }
275
276
277 static void
278 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
279 FLOAT imag_ulp)
280 {
281 if (output_ulps)
282 {
283 if (real_ulp != 0.0)
284 {
285 fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
286 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
287 CHOOSE("ldouble", "double", "float",
288 "ildouble", "idouble", "ifloat"),
289 FUNC(ceil) (real_ulp));
290 }
291 if (imag_ulp != 0.0)
292 {
293 fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
294 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
295 CHOOSE("ldouble", "double", "float",
296 "ildouble", "idouble", "ifloat"),
297 FUNC(ceil) (imag_ulp));
298 }
299
300
301 }
302 }
303
304
305
306 /* Test if Floating-Point stack hasn't changed */
307 static void
308 fpstack_test (const char *test_name)
309 {
310 #ifdef i386
311 static int old_stack;
312 int sw;
313
314 asm ("fnstsw" : "=a" (sw));
315 sw >>= 11;
316 sw &= 7;
317
318 if (sw != old_stack)
319 {
320 printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
321 test_name, sw, old_stack);
322 ++noErrors;
323 old_stack = sw;
324 }
325 #endif
326 }
327
328
329 static void
330 print_max_error (const char *func_name, FLOAT allowed, int xfail)
331 {
332 int ok = 0;
333
334 if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
335 {
336 ok = 1;
337 }
338
339 if (!ok)
340 print_function_ulps (func_name, max_error);
341
342
343 if (print_screen_max_error (ok, xfail))
344 {
345 printf ("Maximal error of `%s'\n", func_name);
346 printf (" is : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
347 printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
348 }
349
350 update_stats (ok, xfail);
351 }
352
353
354 static void
355 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
356 __complex__ int xfail)
357 {
358 int ok = 0;
359
360 if ((real_max_error == 0 && imag_max_error == 0)
361 || (real_max_error <= __real__ allowed
362 && imag_max_error <= __imag__ allowed
363 && !ignore_max_ulp))
364 {
365 ok = 1;
366 }
367
368 if (!ok)
369 print_complex_function_ulps (func_name, real_max_error, imag_max_error);
370
371
372 if (print_screen_max_error (ok, xfail))
373 {
374 printf ("Maximal error of real part of: %s\n", func_name);
375 printf (" is : %.0" PRINTF_NEXPR " ulp\n",
376 FUNC(ceil) (real_max_error));
377 printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
378 FUNC(ceil) (__real__ allowed));
379 printf ("Maximal error of imaginary part of: %s\n", func_name);
380 printf (" is : %.0" PRINTF_NEXPR " ulp\n",
381 FUNC(ceil) (imag_max_error));
382 printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
383 FUNC(ceil) (__imag__ allowed));
384 }
385
386 update_stats (ok, xfail);
387 }
388
389
390 /* Test whether a given exception was raised. */
391 static void
392 test_single_exception (const char *test_name,
393 int exception,
394 int exc_flag,
395 int fe_flag,
396 const char *flag_name)
397 {
398 #ifndef TEST_INLINE
399 int ok = 1;
400 if (exception & exc_flag)
401 {
402 if (fetestexcept (fe_flag))
403 {
404 if (print_screen (1, 0))
405 printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
406 }
407 else
408 {
409 ok = 0;
410 if (print_screen (0, 0))
411 printf ("Failure: %s: Exception \"%s\" not set\n",
412 test_name, flag_name);
413 }
414 }
415 else
416 {
417 if (fetestexcept (fe_flag))
418 {
419 ok = 0;
420 if (print_screen (0, 0))
421 printf ("Failure: %s: Exception \"%s\" set\n",
422 test_name, flag_name);
423 }
424 else
425 {
426 if (print_screen (1, 0))
427 printf ("%s: Exception \"%s\" not set\n", test_name,
428 flag_name);
429 }
430 }
431 if (!ok)
432 ++noErrors;
433
434 #endif
435 }
436
437
438 /* Test whether exceptions given by EXCEPTION are raised. Ignore thereby
439 allowed but not required exceptions.
440 */
441 static void
442 test_exceptions (const char *test_name, int exception)
443 {
444 ++noExcTests;
445 #ifdef FE_DIVBYZERO
446 if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
447 test_single_exception (test_name, exception,
448 DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
449 "Divide by zero");
450 #endif
451 #ifdef FE_INVALID
452 if ((exception & INVALID_EXCEPTION_OK) == 0)
453 test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
454 "Invalid operation");
455 #endif
456 #ifdef FE_OVERFLOW
457 if ((exception & OVERFLOW_EXCEPTION_OK) == 0)
458 test_single_exception (test_name, exception, OVERFLOW_EXCEPTION,
459 FE_OVERFLOW, "Overflow");
460 #endif
461 feclearexcept (FE_ALL_EXCEPT);
462 }
463
464
465 static void
466 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
467 FLOAT max_ulp, int xfail, int exceptions,
468 FLOAT *curr_max_error)
469 {
470 int ok = 0;
471 int print_diff = 0;
472 FLOAT diff = 0;
473 FLOAT ulp = 0;
474
475 test_exceptions (test_name, exceptions);
476 if (isnan (computed) && isnan (expected))
477 ok = 1;
478 else if (isinf (computed) && isinf (expected))
479 {
480 /* Test for sign of infinities. */
481 if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
482 && signbit (computed) != signbit (expected))
483 {
484 ok = 0;
485 printf ("infinity has wrong sign.\n");
486 }
487 else
488 ok = 1;
489 }
490 /* Don't calc ulp for NaNs or infinities. */
491 else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
492 ok = 0;
493 else
494 {
495 diff = FUNC(fabs) (computed - expected);
496 switch (fpclassify (expected))
497 {
498 case FP_ZERO:
499 /* ilogb (0) isn't allowed. */
500 ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
501 break;
502 case FP_NORMAL:
503 ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
504 break;
505 case FP_SUBNORMAL:
506 ulp = (FUNC(ldexp) (diff, MANT_DIG)
507 / FUNC(ldexp) (1.0, FUNC(ilogb) (expected)));
508 break;
509 default:
510 /* It should never happen. */
511 abort ();
512 break;
513 }
514 set_max_error (ulp, curr_max_error);
515 print_diff = 1;
516 if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
517 && computed == 0.0 && expected == 0.0
518 && signbit(computed) != signbit (expected))
519 ok = 0;
520 else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
521 ok = 1;
522 else
523 {
524 ok = 0;
525 print_ulps (test_name, ulp);
526 }
527
528 }
529 if (print_screen (ok, xfail))
530 {
531 if (!ok)
532 printf ("Failure: ");
533 printf ("Test: %s\n", test_name);
534 printf ("Result:\n");
535 printf (" is: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n",
536 computed, computed);
537 printf (" should be: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n",
538 expected, expected);
539 if (print_diff)
540 {
541 printf (" difference: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR
542 "\n", diff, diff);
543 printf (" ulp : % .4" PRINTF_NEXPR "\n", ulp);
544 printf (" max.ulp : % .4" PRINTF_NEXPR "\n", max_ulp);
545 }
546 }
547 update_stats (ok, xfail);
548
549 fpstack_test (test_name);
550 }
551
552
553 static void
554 check_float (const char *test_name, FLOAT computed, FLOAT expected,
555 FLOAT max_ulp, int xfail, int exceptions)
556 {
557 check_float_internal (test_name, computed, expected, max_ulp, xfail,
558 exceptions, &max_error);
559 }
560
561
562 static void
563 check_complex (const char *test_name, __complex__ FLOAT computed,
564 __complex__ FLOAT expected,
565 __complex__ FLOAT max_ulp, __complex__ int xfail,
566 int exception)
567 {
568 FLOAT part_comp, part_exp, part_max_ulp;
569 int part_xfail;
570 char str[200];
571
572 sprintf (str, "Real part of: %s", test_name);
573 part_comp = __real__ computed;
574 part_exp = __real__ expected;
575 part_max_ulp = __real__ max_ulp;
576 part_xfail = __real__ xfail;
577
578 check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
579 exception, &real_max_error);
580
581 sprintf (str, "Imaginary part of: %s", test_name);
582 part_comp = __imag__ computed;
583 part_exp = __imag__ expected;
584 part_max_ulp = __imag__ max_ulp;
585 part_xfail = __imag__ xfail;
586
587 /* Don't check again for exceptions, just pass through the
588 zero/inf sign test. */
589 check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
590 exception & IGNORE_ZERO_INF_SIGN,
591 &imag_max_error);
592 }
593
594
595 /* Check that computed and expected values are equal (int values). */
596 static void
597 check_int (const char *test_name, int computed, int expected, int max_ulp,
598 int xfail, int exceptions)
599 {
600 int diff = computed - expected;
601 int ok = 0;
602
603 test_exceptions (test_name, exceptions);
604 noTests++;
605 if (abs (diff) <= max_ulp)
606 ok = 1;
607
608 if (!ok)
609 print_ulps (test_name, diff);
610
611 if (print_screen (ok, xfail))
612 {
613 if (!ok)
614 printf ("Failure: ");
615 printf ("Test: %s\n", test_name);
616 printf ("Result:\n");
617 printf (" is: %d\n", computed);
618 printf (" should be: %d\n", expected);
619 }
620
621 update_stats (ok, xfail);
622 fpstack_test (test_name);
623 }
624
625
626 /* Check that computed and expected values are equal (long int values). */
627 static void
628 check_long (const char *test_name, long int computed, long int expected,
629 long int max_ulp, int xfail, int exceptions)
630 {
631 long int diff = computed - expected;
632 int ok = 0;
633
634 test_exceptions (test_name, exceptions);
635 noTests++;
636 if (labs (diff) <= max_ulp)
637 ok = 1;
638
639 if (!ok)
640 print_ulps (test_name, diff);
641
642 if (print_screen (ok, xfail))
643 {
644 if (!ok)
645 printf ("Failure: ");
646 printf ("Test: %s\n", test_name);
647 printf ("Result:\n");
648 printf (" is: %ld\n", computed);
649 printf (" should be: %ld\n", expected);
650 }
651
652 update_stats (ok, xfail);
653 fpstack_test (test_name);
654 }
655
656
657 /* Check that computed value is true/false. */
658 static void
659 check_bool (const char *test_name, int computed, int expected,
660 long int max_ulp, int xfail, int exceptions)
661 {
662 int ok = 0;
663
664 test_exceptions (test_name, exceptions);
665 noTests++;
666 if ((computed == 0) == (expected == 0))
667 ok = 1;
668
669 if (print_screen (ok, xfail))
670 {
671 if (!ok)
672 printf ("Failure: ");
673 printf ("Test: %s\n", test_name);
674 printf ("Result:\n");
675 printf (" is: %d\n", computed);
676 printf (" should be: %d\n", expected);
677 }
678
679 update_stats (ok, xfail);
680 fpstack_test (test_name);
681 }
682
683
684 /* check that computed and expected values are equal (long int values) */
685 static void
686 check_longlong (const char *test_name, long long int computed,
687 long long int expected,
688 long long int max_ulp, int xfail,
689 int exceptions)
690 {
691 long long int diff = computed - expected;
692 int ok = 0;
693
694 test_exceptions (test_name, exceptions);
695 noTests++;
696 if (llabs (diff) <= max_ulp)
697 ok = 1;
698
699 if (!ok)
700 print_ulps (test_name, diff);
701
702 if (print_screen (ok, xfail))
703 {
704 if (!ok)
705 printf ("Failure:");
706 printf ("Test: %s\n", test_name);
707 printf ("Result:\n");
708 printf (" is: %lld\n", computed);
709 printf (" should be: %lld\n", expected);
710 }
711
712 update_stats (ok, xfail);
713 fpstack_test (test_name);
714 }
715
716
717
718 /* This is to prevent messages from the SVID libm emulation. */
719 int
720 matherr (struct exception *x __attribute__ ((unused)))
721 {
722 return 1;
723 }
724
725
726 /****************************************************************************
727 Tests for single functions of libm.
728 Please keep them alphabetically sorted!
729 ****************************************************************************/
730
731 static void
732 acos_test (void)
733 {
734 errno = 0;
735 FUNC(acos) (0);
736 if (errno == ENOSYS)
737 /* Function not implemented. */
738 return;
739
740 START (acos);
741
742 TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
743 TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
744 TEST_f_f (acos, nan_value, nan_value);
745
746 /* |x| > 1: */
747 TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
748 TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
749 TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
750 TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
751
752 TEST_f_f (acos, 0, M_PI_2l);
753 TEST_f_f (acos, minus_zero, M_PI_2l);
754 TEST_f_f (acos, 1, 0);
755 TEST_f_f (acos, -1, M_PIl);
756 TEST_f_f (acos, 0.5, M_PI_6l*2.0);
757 TEST_f_f (acos, -0.5, M_PI_6l*4.0);
758 TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
759 TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
760 TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
761 END (acos);
762 }
763
764 static void
765 acosh_test (void)
766 {
767 errno = 0;
768 FUNC(acosh) (7);
769 if (errno == ENOSYS)
770 /* Function not implemented. */
771 return;
772
773 START (acosh);
774
775 TEST_f_f (acosh, plus_infty, plus_infty);
776 TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
777
778 /* x < 1: */
779 TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
780 TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
781
782 TEST_f_f (acosh, 1, 0);
783 TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
784
785 END (acosh);
786 }
787
788 static void
789 asin_test (void)
790 {
791 errno = 0;
792 FUNC(asin) (0);
793 if (errno == ENOSYS)
794 /* Function not implemented. */
795 return;
796
797 START (asin);
798
799 TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
800 TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
801 TEST_f_f (asin, nan_value, nan_value);
802
803 /* asin x == NaN plus invalid exception for |x| > 1. */
804 TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
805 TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
806 TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
807 TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
808
809 TEST_f_f (asin, 0, 0);
810 TEST_f_f (asin, minus_zero, minus_zero);
811 TEST_f_f (asin, 0.5, M_PI_6l);
812 TEST_f_f (asin, -0.5, -M_PI_6l);
813 TEST_f_f (asin, 1.0, M_PI_2l);
814 TEST_f_f (asin, -1.0, -M_PI_2l);
815 TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
816
817 END (asin);
818 }
819
820 static void
821 asinh_test (void)
822 {
823 errno = 0;
824 FUNC(asinh) (0.7L);
825 if (errno == ENOSYS)
826 /* Function not implemented. */
827 return;
828
829 START (asinh);
830
831 TEST_f_f (asinh, 0, 0);
832 TEST_f_f (asinh, minus_zero, minus_zero);
833 #ifndef TEST_INLINE
834 TEST_f_f (asinh, plus_infty, plus_infty);
835 TEST_f_f (asinh, minus_infty, minus_infty);
836 #endif
837 TEST_f_f (asinh, nan_value, nan_value);
838 TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
839
840 END (asinh);
841 }
842
843 static void
844 atan_test (void)
845 {
846 errno = 0;
847 FUNC(atan) (0);
848 if (errno == ENOSYS)
849 /* Function not implemented. */
850 return;
851
852 START (atan);
853
854 TEST_f_f (atan, 0, 0);
855 TEST_f_f (atan, minus_zero, minus_zero);
856
857 TEST_f_f (atan, plus_infty, M_PI_2l);
858 TEST_f_f (atan, minus_infty, -M_PI_2l);
859 TEST_f_f (atan, nan_value, nan_value);
860
861 TEST_f_f (atan, 1, M_PI_4l);
862 TEST_f_f (atan, -1, -M_PI_4l);
863
864 TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
865
866 END (atan);
867 }
868
869
870
871 static void
872 atanh_test (void)
873 {
874 errno = 0;
875 FUNC(atanh) (0.7L);
876 if (errno == ENOSYS)
877 /* Function not implemented. */
878 return;
879
880 START (atanh);
881
882
883 TEST_f_f (atanh, 0, 0);
884 TEST_f_f (atanh, minus_zero, minus_zero);
885
886 TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
887 TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
888 TEST_f_f (atanh, nan_value, nan_value);
889
890 /* atanh (x) == NaN plus invalid exception if |x| > 1. */
891 TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
892 TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
893 TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
894 TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
895
896 TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
897
898 END (atanh);
899 }
900
901 static void
902 atan2_test (void)
903 {
904 errno = 0;
905 FUNC(atan2) (-0, 1);
906 if (errno == ENOSYS)
907 /* Function not implemented. */
908 return;
909
910 START (atan2);
911
912 /* atan2 (0,x) == 0 for x > 0. */
913 TEST_ff_f (atan2, 0, 1, 0);
914
915 /* atan2 (-0,x) == -0 for x > 0. */
916 TEST_ff_f (atan2, minus_zero, 1, minus_zero);
917
918 TEST_ff_f (atan2, 0, 0, 0);
919 TEST_ff_f (atan2, minus_zero, 0, minus_zero);
920
921 /* atan2 (+0,x) == +pi for x < 0. */
922 TEST_ff_f (atan2, 0, -1, M_PIl);
923
924 /* atan2 (-0,x) == -pi for x < 0. */
925 TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
926
927 TEST_ff_f (atan2, 0, minus_zero, M_PIl);
928 TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
929
930 /* atan2 (y,+0) == pi/2 for y > 0. */
931 TEST_ff_f (atan2, 1, 0, M_PI_2l);
932
933 /* atan2 (y,-0) == pi/2 for y > 0. */
934 TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
935
936 /* atan2 (y,+0) == -pi/2 for y < 0. */
937 TEST_ff_f (atan2, -1, 0, -M_PI_2l);
938
939 /* atan2 (y,-0) == -pi/2 for y < 0. */
940 TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
941
942 /* atan2 (y,inf) == +0 for finite y > 0. */
943 TEST_ff_f (atan2, 1, plus_infty, 0);
944
945 /* atan2 (y,inf) == -0 for finite y < 0. */
946 TEST_ff_f (atan2, -1, plus_infty, minus_zero);
947
948 /* atan2(+inf, x) == pi/2 for finite x. */
949 TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
950
951 /* atan2(-inf, x) == -pi/2 for finite x. */
952 TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
953
954 /* atan2 (y,-inf) == +pi for finite y > 0. */
955 TEST_ff_f (atan2, 1, minus_infty, M_PIl);
956
957 /* atan2 (y,-inf) == -pi for finite y < 0. */
958 TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
959
960 TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
961 TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
962 TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
963 TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
964 TEST_ff_f (atan2, nan_value, nan_value, nan_value);
965
966 TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
967
968 TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
969 TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
970 TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
971 TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
972 TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
973 TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
974
975 TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
976
977 END (atan2);
978 }
979
980 static void
981 cabs_test (void)
982 {
983 errno = 0;
984 FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
985 if (errno == ENOSYS)
986 /* Function not implemented. */
987 return;
988
989 START (cabs);
990
991 /* cabs (x + iy) is specified as hypot (x,y) */
992
993 /* cabs (+inf + i x) == +inf. */
994 TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
995 /* cabs (-inf + i x) == +inf. */
996 TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
997
998 TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
999 TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1000
1001 TEST_c_f (cabs, nan_value, nan_value, nan_value);
1002
1003 /* cabs (x,y) == cabs (y,x). */
1004 TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1005 /* cabs (x,y) == cabs (-x,y). */
1006 TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1007 /* cabs (x,y) == cabs (-y,x). */
1008 TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1009 /* cabs (x,y) == cabs (-x,-y). */
1010 TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1011 /* cabs (x,y) == cabs (-y,-x). */
1012 TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1013 /* cabs (x,0) == fabs (x). */
1014 TEST_c_f (cabs, -0.75L, 0, 0.75L);
1015 TEST_c_f (cabs, 0.75L, 0, 0.75L);
1016 TEST_c_f (cabs, -1.0L, 0, 1.0L);
1017 TEST_c_f (cabs, 1.0L, 0, 1.0L);
1018 TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1019 TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1020
1021 TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1022
1023 END (cabs);
1024 }
1025
1026
1027 static void
1028 cacos_test (void)
1029 {
1030 errno = 0;
1031 FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1032 if (errno == ENOSYS)
1033 /* Function not implemented. */
1034 return;
1035
1036 START (cacos);
1037
1038
1039 TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1040 TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1041 TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1042 TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1043
1044 TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1045 TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1046
1047 TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1048 TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1049
1050 TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1051 TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1052 TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1053 TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1054 TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1055 TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1056
1057 TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1058 TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1059 TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1060 TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1061
1062 TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1063 TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1064 TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1065 TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1066
1067 TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1068 TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1069
1070 TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1071 TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1072
1073 TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1074 TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1075
1076 TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1077 TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1078
1079 TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1080 TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1081
1082 TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1083
1084 TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1085 TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1086 TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1087 TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1088 TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1089 TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1090 TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1091 TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1092 TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1093 TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1094 TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1095 TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1096
1097 TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1098 TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1099 TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1100 TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1101 TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1102 TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1103 TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1104 TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1105 TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1106 TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1107 TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1108 TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1109
1110 TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1111 TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1112
1113 END (cacos, complex);
1114 }
1115
1116 static void
1117 cacosh_test (void)
1118 {
1119 errno = 0;
1120 FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1121 if (errno == ENOSYS)
1122 /* Function not implemented. */
1123 return;
1124
1125 START (cacosh);
1126
1127
1128 TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1129 TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1130 TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1131 TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1132 TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1133 TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1134
1135 TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1136 TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1137
1138 TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1139 TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1140 TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1141 TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1142 TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1143 TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1144
1145 TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1146 TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1147 TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1148 TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1149
1150 TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1151 TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1152 TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1153 TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1154
1155 TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1156 TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1157
1158 TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1159 TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1160
1161 TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1162 TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1163
1164 TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1165 TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1166
1167 TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1168 TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1169
1170 TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1171
1172 TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1173 TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1174 TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1175 TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1176 TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1177 TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1178 TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1179 TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1180 TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1181 TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1182 TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1183 TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1184
1185 TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1186 TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1187 TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1188 TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1189 TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1190 TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1191 TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1192 TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1193 TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1194 TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1195 TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1196 TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1197
1198 TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1199 TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1200
1201 END (cacosh, complex);
1202 }
1203
1204
1205 static void
1206 carg_test (void)
1207 {
1208 START (carg);
1209
1210 /* carg (x + iy) is specified as atan2 (y, x) */
1211
1212 /* carg (x + i 0) == 0 for x > 0. */
1213 TEST_c_f (carg, 2.0, 0, 0);
1214 /* carg (x - i 0) == -0 for x > 0. */
1215 TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1216
1217 TEST_c_f (carg, 0, 0, 0);
1218 TEST_c_f (carg, 0, minus_zero, minus_zero);
1219
1220 /* carg (x + i 0) == +pi for x < 0. */
1221 TEST_c_f (carg, -2.0, 0, M_PIl);
1222
1223 /* carg (x - i 0) == -pi for x < 0. */
1224 TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1225
1226 TEST_c_f (carg, minus_zero, 0, M_PIl);
1227 TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1228
1229 /* carg (+0 + i y) == pi/2 for y > 0. */
1230 TEST_c_f (carg, 0, 2.0, M_PI_2l);
1231
1232 /* carg (-0 + i y) == pi/2 for y > 0. */
1233 TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1234
1235 /* carg (+0 + i y) == -pi/2 for y < 0. */
1236 TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1237
1238 /* carg (-0 + i y) == -pi/2 for y < 0. */
1239 TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1240
1241 /* carg (inf + i y) == +0 for finite y > 0. */
1242 TEST_c_f (carg, plus_infty, 2.0, 0);
1243
1244 /* carg (inf + i y) == -0 for finite y < 0. */
1245 TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1246
1247 /* carg(x + i inf) == pi/2 for finite x. */
1248 TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1249
1250 /* carg(x - i inf) == -pi/2 for finite x. */
1251 TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1252
1253 /* carg (-inf + i y) == +pi for finite y > 0. */
1254 TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1255
1256 /* carg (-inf + i y) == -pi for finite y < 0. */
1257 TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1258
1259 TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1260
1261 TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1262
1263 TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1264
1265 TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1266
1267 TEST_c_f (carg, nan_value, nan_value, nan_value);
1268
1269 END (carg);
1270 }
1271
1272 static void
1273 casin_test (void)
1274 {
1275 errno = 0;
1276 FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1277 if (errno == ENOSYS)
1278 /* Function not implemented. */
1279 return;
1280
1281 START (casin);
1282
1283 TEST_c_c (casin, 0, 0, 0.0, 0.0);
1284 TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1285 TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1286 TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1287
1288 TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1289 TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1290 TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1291 TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1292
1293 TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1294 TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1295 TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1296 TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1297 TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1298 TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1299 TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1300 TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1301
1302 TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1303 TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1304 TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1305 TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1306
1307 TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1308 TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1309 TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1310 TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1311
1312 TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1313 TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1314
1315 TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1316 TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1317
1318 TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1319 TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1320
1321 TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1322 TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1323
1324 TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1325 TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1326
1327 TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1328
1329 TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1330 TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1331 TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1332 TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1333 TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1334 TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1335 TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1336 TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1337 TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1338 TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1339 TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1340 TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1341
1342 TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1343 TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1344 TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1345 TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1346 TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1347 TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1348 TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1349 TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1350 TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1351 TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1352 TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1353 TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1354
1355 TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1356 TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1357
1358 END (casin, complex);
1359 }
1360
1361
1362 static void
1363 casinh_test (void)
1364 {
1365 errno = 0;
1366 FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1367 if (errno == ENOSYS)
1368 /* Function not implemented. */
1369 return;
1370
1371 START (casinh);
1372
1373 TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1374 TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1375 TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1376 TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1377
1378 TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1379 TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1380 TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1381 TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1382
1383 TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1384 TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1385 TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1386 TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1387 TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1388 TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1389 TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1390 TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1391
1392 TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1393 TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1394 TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1395 TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1396
1397 TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1398 TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1399 TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1400 TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1401
1402 TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1403 TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1404
1405 TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1406 TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1407
1408 TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1409 TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1410
1411 TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1412 TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1413
1414 TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1415 TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1416
1417 TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1418
1419 TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1420 TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1421 TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1422 TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1423 TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1424 TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1425 TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1426 TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1427 TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1428 TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1429 TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1430 TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1431
1432 TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1433 TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1434 TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1435 TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1436 TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1437 TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1438 TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1439 TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1440 TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1441 TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1442 TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1443 TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1444
1445 TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1446 TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1447
1448 END (casinh, complex);
1449 }
1450
1451
1452 static void
1453 catan_test (void)
1454 {
1455 errno = 0;
1456 FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1457 if (errno == ENOSYS)
1458 /* Function not implemented. */
1459 return;
1460
1461 START (catan);
1462
1463 TEST_c_c (catan, 0, 0, 0, 0);
1464 TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1465 TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1466 TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1467
1468 TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1469 TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1470 TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1471 TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1472
1473
1474 TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1475 TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1476 TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1477 TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1478 TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1479 TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1480 TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1481 TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1482
1483 TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1484 TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1485 TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1486 TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1487
1488 TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1489 TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1490 TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1491 TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1492
1493 TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1494 TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1495
1496 TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1497 TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1498
1499 TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1500 TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1501
1502 TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1503 TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1504
1505 TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1506 TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1507
1508 TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1509 TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1510
1511 TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1512
1513 TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1514 TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1515
1516 END (catan, complex);
1517 }
1518
1519 static void
1520 catanh_test (void)
1521 {
1522 errno = 0;
1523 FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1524 if (errno == ENOSYS)
1525 /* Function not implemented. */
1526 return;
1527
1528 START (catanh);
1529
1530 TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1531 TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1532 TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1533 TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1534
1535 TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1536 TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1537 TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1538 TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1539
1540 TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1541 TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1542 TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1543 TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1544 TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1545 TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1546 TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1547 TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1548
1549 TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1550 TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1551 TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1552 TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1553
1554 TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1555 TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1556 TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1557 TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1558
1559 TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1560 TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1561
1562 TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1563 TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1564
1565 TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1566 TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1567
1568 TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1569 TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1570
1571 TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1572 TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1573
1574 TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1575 TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1576
1577 TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1578
1579 TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1580 TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1581
1582 END (catanh, complex);
1583 }
1584
1585 static void
1586 cbrt_test (void)
1587 {
1588 errno = 0;
1589 FUNC(cbrt) (8);
1590 if (errno == ENOSYS)
1591 /* Function not implemented. */
1592 return;
1593
1594 START (cbrt);
1595
1596 TEST_f_f (cbrt, 0.0, 0.0);
1597 TEST_f_f (cbrt, minus_zero, minus_zero);
1598
1599 TEST_f_f (cbrt, plus_infty, plus_infty);
1600 TEST_f_f (cbrt, minus_infty, minus_infty);
1601 TEST_f_f (cbrt, nan_value, nan_value);
1602
1603 TEST_f_f (cbrt, -0.001L, -0.1L);
1604 TEST_f_f (cbrt, 8, 2);
1605 TEST_f_f (cbrt, -27.0, -3.0);
1606 TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1607 TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1608
1609 END (cbrt);
1610 }
1611
1612
1613 static void
1614 ccos_test (void)
1615 {
1616 errno = 0;
1617 FUNC(ccos) (BUILD_COMPLEX (0, 0));
1618 if (errno == ENOSYS)
1619 /* Function not implemented. */
1620 return;
1621
1622 START (ccos);
1623
1624 TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1625 TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1626 TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1627 TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1628
1629 TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1630 TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1631 TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1632 TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1633
1634 TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1635 TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1636 TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1637 TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1638
1639 TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1640 TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1641 TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1642 TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1643
1644 TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1645 TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1646 TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1647 TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1648
1649 TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1650 TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1651 TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1652 TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1653
1654 TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1655 TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1656
1657 TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1658 TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1659
1660 TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1661 TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1662
1663 TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1664 TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1665
1666 TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1667 TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1668
1669 TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1670 TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1671
1672 TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1673
1674 TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1675 TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1676
1677 END (ccos, complex);
1678 }
1679
1680
1681 static void
1682 ccosh_test (void)
1683 {
1684 errno = 0;
1685 FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
1686 if (errno == ENOSYS)
1687 /* Function not implemented. */
1688 return;
1689
1690 START (ccosh);
1691
1692 TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1693 TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1694 TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1695 TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1696
1697 TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1698 TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1699 TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1700 TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1701
1702 TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1703 TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1704 TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1705 TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1706
1707 TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1708 TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1709 TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1710 TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1711
1712 TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1713 TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1714 TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1715 TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1716
1717 TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1718 TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1719 TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1720 TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1721
1722 TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1723 TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1724
1725 TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1726 TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1727
1728 TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1729 TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1730
1731 TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1732 TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1733
1734 TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1735 TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1736
1737 TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1738 TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1739
1740 TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1741
1742 TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
1743
1744 TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
1745
1746 END (ccosh, complex);
1747 }
1748
1749
1750 static void
1751 ceil_test (void)
1752 {
1753 START (ceil);
1754
1755 TEST_f_f (ceil, 0.0, 0.0);
1756 TEST_f_f (ceil, minus_zero, minus_zero);
1757 TEST_f_f (ceil, plus_infty, plus_infty);
1758 TEST_f_f (ceil, minus_infty, minus_infty);
1759 TEST_f_f (ceil, nan_value, nan_value);
1760
1761 TEST_f_f (ceil, M_PIl, 4.0);
1762 TEST_f_f (ceil, -M_PIl, -3.0);
1763 TEST_f_f (ceil, 0.1, 1.0);
1764 TEST_f_f (ceil, 0.25, 1.0);
1765 TEST_f_f (ceil, 0.625, 1.0);
1766 TEST_f_f (ceil, -0.1, minus_zero);
1767 TEST_f_f (ceil, -0.25, minus_zero);
1768 TEST_f_f (ceil, -0.625, minus_zero);
1769
1770 #ifdef TEST_LDOUBLE
1771 /* The result can only be represented in long double. */
1772 TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
1773 TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
1774 TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
1775 TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
1776 TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
1777
1778 TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
1779 TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
1780 TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
1781 TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
1782 TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
1783
1784 # if LDBL_MANT_DIG > 100
1785 TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
1786 TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
1787 TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
1788 TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
1789 TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
1790 TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
1791 # endif
1792
1793 TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
1794 TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
1795 TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
1796 TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
1797 TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
1798
1799 TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
1800 TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
1801 TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
1802 TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
1803 TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
1804
1805 # if LDBL_MANT_DIG > 100
1806 TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
1807 TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
1808 TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
1809 TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
1810 TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
1811 TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
1812
1813 TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
1814 TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
1815 TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
1816 TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
1817 TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
1818 TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
1819 # endif
1820
1821 TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
1822 TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
1823 TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
1824 TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
1825 TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
1826
1827 TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
1828 TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
1829 TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
1830 TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
1831 TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
1832
1833 TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
1834 TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
1835 TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
1836 TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
1837 TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
1838 #endif
1839
1840 END (ceil);
1841 }
1842
1843
1844 static void
1845 cexp_test (void)
1846 {
1847 errno = 0;
1848 FUNC(cexp) (BUILD_COMPLEX (0, 0));
1849 if (errno == ENOSYS)
1850 /* Function not implemented. */
1851 return;
1852
1853 START (cexp);
1854
1855 TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1856 TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1857 TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1858 TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1859
1860 TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1861 TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1862
1863 TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1864 TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1865
1866 TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1867 TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1868
1869 TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1870 TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1871
1872 TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1873 TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1874
1875 TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1876 TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1877
1878 TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1879 TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1880 TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1881 TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1882
1883 TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1884 TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1885
1886 TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1887 TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1888
1889 TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1890
1891 TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1892
1893 TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1894 TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1895
1896 TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1897 TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1898 TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1899 TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1900
1901 TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
1902 TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
1903
1904 TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
1905 TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
1906 TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
1907
1908 #ifndef TEST_FLOAT
1909 TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
1910 TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
1911 TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
1912 #endif
1913
1914 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1915 TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
1916 TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
1917 #endif
1918
1919 TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
1920 TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L);
1921
1922 #ifndef TEST_FLOAT
1923 TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
1924 TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L);
1925 #endif
1926
1927 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1928 TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
1929 TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L);
1930 #endif
1931
1932 #ifdef TEST_FLOAT
1933 TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
1934 #endif
1935
1936 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
1937 TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
1938 #endif
1939
1940 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1941 TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
1942 #endif
1943
1944 TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
1945 TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
1946 TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
1947
1948 END (cexp, complex);
1949 }
1950
1951
1952 static void
1953 cimag_test (void)
1954 {
1955 START (cimag);
1956 TEST_c_f (cimag, 1.0, 0.0, 0.0);
1957 TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1958 TEST_c_f (cimag, 1.0, nan_value, nan_value);
1959 TEST_c_f (cimag, nan_value, nan_value, nan_value);
1960 TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1961 TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1962 TEST_c_f (cimag, 2.0, 3.0, 3.0);
1963
1964 END (cimag);
1965 }
1966
1967 static void
1968 clog_test (void)
1969 {
1970 errno = 0;
1971 FUNC(clog) (BUILD_COMPLEX (-2, -3));
1972 if (errno == ENOSYS)
1973 /* Function not implemented. */
1974 return;
1975
1976 START (clog);
1977
1978 TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1979 TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1980
1981 TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1982 TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1983
1984 TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1985 TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1986
1987 TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1988 TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1989
1990 TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1991 TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1992 TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1993 TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1994 TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1995 TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1996 TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1997 TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1998
1999 TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2000 TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2001 TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2002 TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2003
2004 TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2005 TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2006 TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2007 TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2008
2009 TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2010 TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2011
2012 TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2013 TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2014
2015 TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2016 TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2017 TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2018 TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2019
2020 TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2021 TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2022 TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2023 TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2024
2025 TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2026
2027 TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2028 TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2029
2030 TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2031 TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L);
2032 TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2033 TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2034
2035 #ifndef TEST_FLOAT
2036 TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2037 TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2038 TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2039 TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2040 #endif
2041
2042 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2043 TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2044 TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2045 TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2046 #endif
2047
2048 END (clog, complex);
2049 }
2050
2051
2052 static void
2053 clog10_test (void)
2054 {
2055 errno = 0;
2056 FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2057 if (errno == ENOSYS)
2058 /* Function not implemented. */
2059 return;
2060
2061 START (clog10);
2062
2063 TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2064 TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2065
2066 TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2067 TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2068
2069 TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2070
2071 TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2072 TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2073
2074 TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2075 TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2076 TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2077 TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2078 TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2079 TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2080 TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2081 TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2082
2083 TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2084 TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2085 TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2086 TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2087
2088 TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2089 TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2090 TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2091 TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2092
2093 TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2094 TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2095
2096 TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2097 TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2098
2099 TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2100 TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2101 TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2102 TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2103
2104 TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2105 TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2106 TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2107 TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2108
2109 TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2110
2111 TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2112 TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2113
2114 TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2115 TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L);
2116 TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2117 TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2118
2119 #ifndef TEST_FLOAT
2120 TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2121 TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2122 TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2123 TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2124 #endif
2125
2126 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2127 TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2128 TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2129 TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2130 #endif
2131
2132 END (clog10, complex);
2133 }
2134
2135
2136 static void
2137 conj_test (void)
2138 {
2139 START (conj);
2140 TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2141 TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2142 TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2143 TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2144 TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2145 TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2146 TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2147
2148 END (conj, complex);
2149 }
2150
2151
2152 static void
2153 copysign_test (void)
2154 {
2155 START (copysign);
2156
2157 TEST_ff_f (copysign, 0, 4, 0);
2158 TEST_ff_f (copysign, 0, -4, minus_zero);
2159 TEST_ff_f (copysign, minus_zero, 4, 0);
2160 TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2161
2162 TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2163 TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2164 TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2165 TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2166
2167 TEST_ff_f (copysign, 0, plus_infty, 0);
2168 TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2169 TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2170 TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2171
2172 /* XXX More correctly we would have to check the sign of the NaN. */
2173 TEST_ff_f (copysign, nan_value, 0, nan_value);
2174 TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2175 TEST_ff_f (copysign, -nan_value, 0, nan_value);
2176 TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2177
2178 END (copysign);
2179 }
2180
2181
2182 static void
2183 cos_test (void)
2184 {
2185 errno = 0;
2186 FUNC(cos) (0);
2187 if (errno == ENOSYS)
2188 /* Function not implemented. */
2189 return;
2190
2191 START (cos);
2192
2193 TEST_f_f (cos, 0, 1);
2194 TEST_f_f (cos, minus_zero, 1);
2195 errno = 0;
2196 TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2197 check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2198 errno = 0;
2199 TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2200 check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2201 errno = 0;
2202 TEST_f_f (cos, nan_value, nan_value);
2203 check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2204
2205 TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2206 TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2207 TEST_f_f (cos, M_PI_2l, 0);
2208
2209 TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2210
2211 TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2212 TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2213
2214 #ifdef TEST_DOUBLE
2215 TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2216 #endif
2217
2218 #ifndef TEST_FLOAT
2219 TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2220 TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2221 #endif
2222
2223 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2224 TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2225 #endif
2226
2227 END (cos);
2228 }
2229
2230
2231 static void
2232 cos_test_tonearest (void)
2233 {
2234 int save_round_mode;
2235 errno = 0;
2236 FUNC(cos) (0);
2237 if (errno == ENOSYS)
2238 /* Function not implemented. */
2239 return;
2240
2241 START (cos_tonearest);
2242
2243 save_round_mode = fegetround ();
2244
2245 if (!fesetround (FE_TONEAREST))
2246 {
2247 TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2248 TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2249 TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2250 TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2251 TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2252 TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2253 TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2254 TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2255 TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2256 TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2257 }
2258
2259 fesetround (save_round_mode);
2260
2261 END (cos_tonearest);
2262 }
2263
2264
2265 static void
2266 cos_test_towardzero (void)
2267 {
2268 int save_round_mode;
2269 errno = 0;
2270 FUNC(cos) (0);
2271 if (errno == ENOSYS)
2272 /* Function not implemented. */
2273 return;
2274
2275 START (cos_towardzero);
2276
2277 save_round_mode = fegetround ();
2278
2279 if (!fesetround (FE_TOWARDZERO))
2280 {
2281 TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2282 TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2283 TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2284 TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2285 TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2286 TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2287 TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2288 TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2289 TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2290 TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2291 }
2292
2293 fesetround (save_round_mode);
2294
2295 END (cos_towardzero);
2296 }
2297
2298
2299 static void
2300 cos_test_downward (void)
2301 {
2302 int save_round_mode;
2303 errno = 0;
2304 FUNC(cos) (0);
2305 if (errno == ENOSYS)
2306 /* Function not implemented. */
2307 return;
2308
2309 START (cos_downward);
2310
2311 save_round_mode = fegetround ();
2312
2313 if (!fesetround (FE_DOWNWARD))
2314 {
2315 TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2316 TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2317 TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2318 TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2319 TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2320 TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2321 TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2322 TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2323 TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2324 TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2325 }
2326
2327 fesetround (save_round_mode);
2328
2329 END (cos_downward);
2330 }
2331
2332
2333 static void
2334 cos_test_upward (void)
2335 {
2336 int save_round_mode;
2337 errno = 0;
2338 FUNC(cos) (0);
2339 if (errno == ENOSYS)
2340 /* Function not implemented. */
2341 return;
2342
2343 START (cos_upward);
2344
2345 save_round_mode = fegetround ();
2346
2347 if (!fesetround (FE_UPWARD))
2348 {
2349 TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2350 TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2351 TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2352 TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2353 TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2354 TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2355 TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2356 TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2357 TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2358 TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2359 }
2360
2361 fesetround (save_round_mode);
2362
2363 END (cos_upward);
2364 }
2365
2366
2367 static void
2368 cosh_test (void)
2369 {
2370 errno = 0;
2371 FUNC(cosh) (0.7L);
2372 if (errno == ENOSYS)
2373 /* Function not implemented. */
2374 return;
2375
2376 START (cosh);
2377 TEST_f_f (cosh, 0, 1);
2378 TEST_f_f (cosh, minus_zero, 1);
2379
2380 #ifndef TEST_INLINE
2381 TEST_f_f (cosh, plus_infty, plus_infty);
2382 TEST_f_f (cosh, minus_infty, plus_infty);
2383 #endif
2384 TEST_f_f (cosh, nan_value, nan_value);
2385
2386 TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2387
2388 END (cosh);
2389 }
2390
2391
2392 static void
2393 cosh_test_tonearest (void)
2394 {
2395 int save_round_mode;
2396 errno = 0;
2397 FUNC(cosh) (0);
2398 if (errno == ENOSYS)
2399 /* Function not implemented. */
2400 return;
2401
2402 START (cosh_tonearest);
2403
2404 save_round_mode = fegetround ();
2405
2406 if (!fesetround (FE_TONEAREST))
2407 {
2408 TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2409 TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2410 TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2411 }
2412
2413 fesetround (save_round_mode);
2414
2415 END (cosh_tonearest);
2416 }
2417
2418
2419 static void
2420 cosh_test_towardzero (void)
2421 {
2422 int save_round_mode;
2423 errno = 0;
2424 FUNC(cosh) (0);
2425 if (errno == ENOSYS)
2426 /* Function not implemented. */
2427 return;
2428
2429 START (cosh_towardzero);
2430
2431 save_round_mode = fegetround ();
2432
2433 if (!fesetround (FE_TOWARDZERO))
2434 {
2435 TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2436 TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2437 TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2438 }
2439
2440 fesetround (save_round_mode);
2441
2442 END (cosh_towardzero);
2443 }
2444
2445
2446 static void
2447 cosh_test_downward (void)
2448 {
2449 int save_round_mode;
2450 errno = 0;
2451 FUNC(cosh) (0);
2452 if (errno == ENOSYS)
2453 /* Function not implemented. */
2454 return;
2455
2456 START (cosh_downward);
2457
2458 save_round_mode = fegetround ();
2459
2460 if (!fesetround (FE_DOWNWARD))
2461 {
2462 TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2463 TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2464 TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2465 }
2466
2467 fesetround (save_round_mode);
2468
2469 END (cosh_downward);
2470 }
2471
2472
2473 static void
2474 cosh_test_upward (void)
2475 {
2476 int save_round_mode;
2477 errno = 0;
2478 FUNC(cosh) (0);
2479 if (errno == ENOSYS)
2480 /* Function not implemented. */
2481 return;
2482
2483 START (cosh_upward);
2484
2485 save_round_mode = fegetround ();
2486
2487 if (!fesetround (FE_UPWARD))
2488 {
2489 TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2490 TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2491 TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2492 }
2493
2494 fesetround (save_round_mode);
2495
2496 END (cosh_upward);
2497 }
2498
2499
2500 static void
2501 cpow_test (void)
2502 {
2503 errno = 0;
2504 FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2505 if (errno == ENOSYS)
2506 /* Function not implemented. */
2507 return;
2508
2509 START (cpow);
2510
2511 TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2512 TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2513
2514 TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2515 TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2516
2517 TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2518
2519 TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2520 TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2521 TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2522 TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2523
2524 END (cpow, complex);
2525 }
2526
2527
2528 static void
2529 cproj_test (void)
2530 {
2531 START (cproj);
2532 TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2533 TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2534 TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2535 TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2536
2537 TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2538
2539 TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2540 TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2541 TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2542 TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2543
2544 TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2545 TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
2546
2547 END (cproj, complex);
2548 }
2549
2550
2551 static void
2552 creal_test (void)
2553 {
2554 START (creal);
2555 TEST_c_f (creal, 0.0, 1.0, 0.0);
2556 TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2557 TEST_c_f (creal, nan_value, 1.0, nan_value);
2558 TEST_c_f (creal, nan_value, nan_value, nan_value);
2559 TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2560 TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2561 TEST_c_f (creal, 2.0, 3.0, 2.0);
2562
2563 END (creal);
2564 }
2565
2566 static void
2567 csin_test (void)
2568 {
2569 errno = 0;
2570 FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2571 if (errno == ENOSYS)
2572 /* Function not implemented. */
2573 return;
2574
2575 START (csin);
2576
2577 TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2578 TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2579 TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2580 TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2581
2582 TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2583 TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2584 TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2585 TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2586
2587 TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2588 TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2589 TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2590 TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2591
2592 TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2593 TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2594 TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2595 TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2596
2597 TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2598 TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2599 TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2600 TEST_c_c (csin, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2601
2602 TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2603 TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2604 TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2605 TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2606
2607 TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2608 TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2609
2610 TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2611 TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2612
2613 TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2614 TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2615
2616 TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2617 TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2618
2619 TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2620 TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2621
2622 TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2623 TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2624
2625 TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2626
2627 TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2628 TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2629
2630 END (csin, complex);
2631 }
2632
2633
2634 static void
2635 csinh_test (void)
2636 {
2637 errno = 0;
2638 FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2639 if (errno == ENOSYS)
2640 /* Function not implemented. */
2641 return;
2642
2643 START (csinh);
2644
2645 TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2646 TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2647 TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2648 TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2649
2650 TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2651 TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2652 TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2653 TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2654
2655 TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2656 TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2657 TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2658 TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2659
2660 TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2661 TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2662 TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2663 TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2664
2665 TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2666 TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2667 TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2668 TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2669
2670 TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2671 TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2672 TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2673 TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2674
2675 TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2676 TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2677
2678 TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2679 TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2680
2681 TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2682 TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2683
2684 TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2685 TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2686
2687 TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2688 TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2689
2690 TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2691 TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2692
2693 TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2694
2695 TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2696 TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2697
2698 END (csinh, complex);
2699 }
2700
2701
2702 static void
2703 csqrt_test (void)
2704 {
2705 errno = 0;
2706 FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2707 if (errno == ENOSYS)
2708 /* Function not implemented. */
2709 return;
2710
2711 START (csqrt);
2712
2713 TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2714 TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2715 TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2716 TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2717
2718 TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2719 TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2720 TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2721 TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2722
2723 TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2724 TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2725 TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2726 TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2727
2728 TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2729 TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2730 TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2731 TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2732 TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2733 TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2734 TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2735 TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2736 TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2737 TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2738 TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2739 TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2740
2741 TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2742
2743 TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2744
2745 TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2746 TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2747 TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2748 TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2749
2750 TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2751 TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2752 TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2753 TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2754
2755 TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2756
2757 TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2758 TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2759 TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2760 TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2761 TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2762 TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2763 TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2764 /* Principal square root should be returned (i.e., non-negative real
2765 part). */
2766 TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2767
2768 TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
2769 TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
2770 TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
2771 TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
2772
2773 #ifndef TEST_FLOAT
2774 TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
2775 TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
2776 TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
2777 TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
2778 #endif
2779
2780 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2781 TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
2782 TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
2783 TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L, 8.297059146828716918029689466551384219370e-2476L);
2784 #endif
2785
2786 END (csqrt, complex);
2787 }
2788
2789 static void
2790 ctan_test (void)
2791 {
2792 errno = 0;
2793 FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2794 if (errno == ENOSYS)
2795 /* Function not implemented. */
2796 return;
2797
2798 START (ctan);
2799
2800 TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2801 TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2802 TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2803 TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2804
2805 TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2806 TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2807 TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2808 TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2809
2810 TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2811 TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2812 TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2813 TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2814
2815 TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2816 TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2817 TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2818 TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2819 TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2820 TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2821 TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2822 TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2823
2824 TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2825 TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2826
2827 TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2828 TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2829
2830 TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2831 TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2832
2833 TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2834 TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2835 TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2836 TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2837
2838 TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2839
2840 TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2841 TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2842
2843 END (ctan, complex);
2844 }
2845
2846
2847 static void
2848 ctanh_test (void)
2849 {
2850 errno = 0;
2851 FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2852 if (errno == ENOSYS)
2853 /* Function not implemented. */
2854 return;
2855
2856 START (ctanh);
2857
2858 TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2859 TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2860 TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2861 TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2862
2863 TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2864 TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2865 TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2866 TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2867 TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2868 TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2869 TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2870 TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2871
2872 TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2873 TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2874 TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2875 TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2876 TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2877 TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2878 TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2879 TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2880
2881 TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2882 TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2883
2884 TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2885 TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2886
2887 TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2888 TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2889
2890 TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2891 TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2892 TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2893 TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2894
2895 TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2896
2897 TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2898
2899 TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2900 TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2901
2902 END (ctanh, complex);
2903 }
2904
2905
2906 static void
2907 erf_test (void)
2908 {
2909 errno = 0;
2910 FUNC(erf) (0);
2911 if (errno == ENOSYS)
2912 /* Function not implemented. */
2913 return;
2914
2915 START (erf);
2916
2917 TEST_f_f (erf, 0, 0);
2918 TEST_f_f (erf, minus_zero, minus_zero);
2919 TEST_f_f (erf, plus_infty, 1);
2920 TEST_f_f (erf, minus_infty, -1);
2921 TEST_f_f (erf, nan_value, nan_value);
2922
2923 TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2924 TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2925 TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2926 TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2927 TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2928 TEST_f_f (erf, 27.0L, 1.0L);
2929
2930 END (erf);
2931 }
2932
2933
2934 static void
2935 erfc_test (void)
2936 {
2937 errno = 0;
2938 FUNC(erfc) (0);
2939 if (errno == ENOSYS)
2940 /* Function not implemented. */
2941 return;
2942
2943 START (erfc);
2944
2945 TEST_f_f (erfc, plus_infty, 0.0);
2946 TEST_f_f (erfc, minus_infty, 2.0);
2947 TEST_f_f (erfc, 0.0, 1.0);
2948 TEST_f_f (erfc, minus_zero, 1.0);
2949 TEST_f_f (erfc, nan_value, nan_value);
2950
2951 TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
2952 TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
2953 TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
2954 TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
2955 TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
2956 TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
2957 TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
2958 TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
2959 #ifdef TEST_LDOUBLE
2960 /* The result can only be represented in long double. */
2961 # if LDBL_MIN_10_EXP < -319
2962 TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
2963 # endif
2964 # if LDBL_MANT_DIG >= 106
2965 TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
2966 # endif
2967 #endif
2968
2969 END (erfc);
2970 }
2971
2972
2973 static void
2974 exp_test (void)
2975 {
2976 errno = 0;
2977 FUNC(exp) (0);
2978 if (errno == ENOSYS)
2979 /* Function not implemented. */
2980 return;
2981
2982 START (exp);
2983
2984 TEST_f_f (exp, 0, 1);
2985 TEST_f_f (exp, minus_zero, 1);
2986
2987 #ifndef TEST_INLINE
2988 TEST_f_f (exp, plus_infty, plus_infty);
2989 TEST_f_f (exp, minus_infty, 0);
2990 #endif
2991 TEST_f_f (exp, nan_value, nan_value);
2992 TEST_f_f (exp, 1, M_El);
2993
2994 TEST_f_f (exp, 2, M_E2l);
2995 TEST_f_f (exp, 3, M_E3l);
2996 TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
2997 TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
2998 TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
2999 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
3000 /* The result can only be represented in sane long double. */
3001 TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
3002 #endif
3003
3004 /* Bug 13922: OVERFLOW exception may be missing. */
3005 TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
3006 /* Bug 13705: spurious OVERFLOW exception may be present. */
3007 TEST_f_f (exp, -max_value, 0, OVERFLOW_EXCEPTION_OK);
3008
3009 END (exp);
3010 }
3011
3012
3013 static void
3014 exp_test_tonearest (void)
3015 {
3016 int save_round_mode;
3017 errno = 0;
3018 FUNC(exp) (0);
3019 if (errno == ENOSYS)
3020 /* Function not implemented. */
3021 return;
3022
3023 START (exp_tonearest);
3024
3025 save_round_mode = fegetround ();
3026
3027 if (!fesetround (FE_TONEAREST))
3028 {
3029 TEST_f_f (exp, 1, M_El);
3030 TEST_f_f (exp, 2, M_E2l);
3031 TEST_f_f (exp, 3, M_E3l);
3032 }
3033
3034 fesetround (save_round_mode);
3035
3036 END (exp_tonearest);
3037 }
3038
3039
3040 static void
3041 exp_test_towardzero (void)
3042 {
3043 int save_round_mode;
3044 errno = 0;
3045 FUNC(exp) (0);
3046 if (errno == ENOSYS)
3047 /* Function not implemented. */
3048 return;
3049
3050 START (exp_towardzero);
3051
3052 save_round_mode = fegetround ();
3053
3054 if (!fesetround (FE_TOWARDZERO))
3055 {
3056 TEST_f_f (exp, 1, M_El);
3057 TEST_f_f (exp, 2, M_E2l);
3058 TEST_f_f (exp, 3, M_E3l);
3059 }
3060
3061 fesetround (save_round_mode);
3062
3063 END (exp_towardzero);
3064 }
3065
3066
3067 static void
3068 exp_test_downward (void)
3069 {
3070 int save_round_mode;
3071 errno = 0;
3072 FUNC(exp) (0);
3073 if (errno == ENOSYS)
3074 /* Function not implemented. */
3075 return;
3076
3077 START (exp_downward);
3078
3079 save_round_mode = fegetround ();
3080
3081 if (!fesetround (FE_DOWNWARD))
3082 {
3083 TEST_f_f (exp, 1, M_El);
3084 TEST_f_f (exp, 2, M_E2l);
3085 TEST_f_f (exp, 3, M_E3l);
3086 }
3087
3088 fesetround (save_round_mode);
3089
3090 END (exp_downward);
3091 }
3092
3093
3094 static void
3095 exp_test_upward (void)
3096 {
3097 int save_round_mode;
3098 errno = 0;
3099 FUNC(exp) (0);
3100 if (errno == ENOSYS)
3101 /* Function not implemented. */
3102 return;
3103
3104 START (exp_upward);
3105
3106 save_round_mode = fegetround ();
3107
3108 if (!fesetround (FE_UPWARD))
3109 {
3110 TEST_f_f (exp, 1, M_El);
3111 TEST_f_f (exp, 2, M_E2l);
3112 TEST_f_f (exp, 3, M_E3l);
3113 }
3114
3115 fesetround (save_round_mode);
3116
3117 END (exp_upward);
3118 }
3119
3120
3121 static void
3122 exp10_test (void)
3123 {
3124 errno = 0;
3125 FUNC(exp10) (0);
3126 if (errno == ENOSYS)
3127 /* Function not implemented. */
3128 return;
3129
3130 START (exp10);
3131
3132 TEST_f_f (exp10, 0, 1);
3133 TEST_f_f (exp10, minus_zero, 1);
3134
3135 TEST_f_f (exp10, plus_infty, plus_infty);
3136 TEST_f_f (exp10, minus_infty, 0);
3137 TEST_f_f (exp10, nan_value, nan_value);
3138 TEST_f_f (exp10, 3, 1000);
3139 TEST_f_f (exp10, -1, 0.1L);
3140 TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3141 TEST_f_f (exp10, -1e6, 0);
3142 #ifndef TEST_LDOUBLE /* Bug 13914: spurious exceptions. */
3143 TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
3144 /* Bug 13924: spurious OVERFLOW exception may be present. */
3145 TEST_f_f (exp10, -max_value, 0, OVERFLOW_EXCEPTION_OK);
3146 #endif
3147 TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
3148
3149 END (exp10);
3150 }
3151
3152
3153 static void
3154 exp2_test (void)
3155 {
3156 errno = 0;
3157 FUNC(exp2) (0);
3158 if (errno == ENOSYS)
3159 /* Function not implemented. */
3160 return;
3161
3162 START (exp2);
3163
3164 TEST_f_f (exp2, 0, 1);
3165 TEST_f_f (exp2, minus_zero, 1);
3166 TEST_f_f (exp2, plus_infty, plus_infty);
3167 TEST_f_f (exp2, minus_infty, 0);
3168 TEST_f_f (exp2, nan_value, nan_value);
3169
3170 TEST_f_f (exp2, 10, 1024);
3171 TEST_f_f (exp2, -1, 0.5);
3172 TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3173 TEST_f_f (exp2, -1e6, 0);
3174 TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
3175 TEST_f_f (exp2, -max_value, 0);
3176 TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
3177
3178 TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
3179 TEST_f_f (exp2, 127, 0x1p127);
3180 TEST_f_f (exp2, -149, 0x1p-149);
3181
3182 #ifndef TEST_FLOAT
3183 TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
3184 TEST_f_f (exp2, 1023, 0x1p1023);
3185 TEST_f_f (exp2, -1074, 0x1p-1074);
3186 #endif
3187
3188 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3189 TEST_f_f (exp2, 16383, 0x1p16383L);
3190 TEST_f_f (exp2, -16400, 0x1p-16400L);
3191 #endif
3192
3193 END (exp2);
3194 }
3195
3196
3197 static void
3198 expm1_test (void)
3199 {
3200 errno = 0;
3201 FUNC(expm1) (0);
3202 if (errno == ENOSYS)
3203 /* Function not implemented. */
3204 return;
3205
3206 START (expm1);
3207
3208 TEST_f_f (expm1, 0, 0);
3209 TEST_f_f (expm1, minus_zero, minus_zero);
3210
3211 #ifndef TEST_INLINE
3212 TEST_f_f (expm1, plus_infty, plus_infty);
3213 TEST_f_f (expm1, minus_infty, -1);
3214 #endif
3215 TEST_f_f (expm1, nan_value, nan_value);
3216
3217 TEST_f_f (expm1, 1, M_El - 1.0);
3218 TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
3219
3220 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3221 TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
3222 #endif
3223
3224 errno = 0;
3225 /* Bug 13787: OVERFLOW exception may be missing. */
3226 TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION_OK);
3227 check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
3228 /* Bug 13787: OVERFLOW exception may be missing. */
3229 TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
3230 #ifndef TEST_LDOUBLE /* Bug 13923. */
3231 TEST_f_f (expm1, -max_value, -1);
3232 #endif
3233
3234 END (expm1);
3235 }
3236
3237
3238 static void
3239 fabs_test (void)
3240 {
3241 START (fabs);
3242
3243 TEST_f_f (fabs, 0, 0);
3244 TEST_f_f (fabs, minus_zero, 0);
3245
3246 TEST_f_f (fabs, plus_infty, plus_infty);
3247 TEST_f_f (fabs, minus_infty, plus_infty);
3248 TEST_f_f (fabs, nan_value, nan_value);
3249
3250 TEST_f_f (fabs, 38.0, 38.0);
3251 TEST_f_f (fabs, -M_El, M_El);
3252
3253 END (fabs);
3254 }
3255
3256
3257 static void
3258 fdim_test (void)
3259 {
3260 START (fdim);
3261
3262 TEST_ff_f (fdim, 0, 0, 0);
3263 TEST_ff_f (fdim, 9, 0, 9);
3264 TEST_ff_f (fdim, 0, 9, 0);
3265 TEST_ff_f (fdim, -9, 0, 0);
3266 TEST_ff_f (fdim, 0, -9, 9);
3267
3268 TEST_ff_f (fdim, plus_infty, 9, plus_infty);
3269 TEST_ff_f (fdim, plus_infty, -9, plus_infty);
3270 TEST_ff_f (fdim, minus_infty, 9, 0);
3271 TEST_ff_f (fdim, minus_infty, -9, 0);
3272 TEST_ff_f (fdim, 9, minus_infty, plus_infty);
3273 TEST_ff_f (fdim, -9, minus_infty, plus_infty);
3274 TEST_ff_f (fdim, 9, plus_infty, 0);
3275 TEST_ff_f (fdim, -9, plus_infty, 0);
3276
3277 TEST_ff_f (fdim, 0, nan_value, nan_value);
3278 TEST_ff_f (fdim, 9, nan_value, nan_value);
3279 TEST_ff_f (fdim, -9, nan_value, nan_value);
3280 TEST_ff_f (fdim, nan_value, 9, nan_value);
3281 TEST_ff_f (fdim, nan_value, -9, nan_value);
3282 TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
3283 TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
3284 TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
3285 TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
3286 TEST_ff_f (fdim, nan_value, nan_value, nan_value);
3287
3288 TEST_ff_f (fdim, plus_infty, plus_infty, 0);
3289
3290 END (fdim);
3291 }
3292
3293
3294 static void
3295 floor_test (void)
3296 {
3297 START (floor);
3298
3299 TEST_f_f (floor, 0.0, 0.0);
3300 TEST_f_f (floor, minus_zero, minus_zero);
3301 TEST_f_f (floor, plus_infty, plus_infty);
3302 TEST_f_f (floor, minus_infty, minus_infty);
3303 TEST_f_f (floor, nan_value, nan_value);
3304
3305 TEST_f_f (floor, M_PIl, 3.0);
3306 TEST_f_f (floor, -M_PIl, -4.0);
3307
3308 TEST_f_f (floor, 0.1, 0.0);
3309 TEST_f_f (floor, 0.25, 0.0);
3310 TEST_f_f (floor, 0.625, 0.0);
3311 TEST_f_f (floor, -0.1, -1.0);
3312 TEST_f_f (floor, -0.25, -1.0);
3313 TEST_f_f (floor, -0.625, -1.0);
3314
3315 #ifdef TEST_LDOUBLE
3316 /* The result can only be represented in long double. */
3317 TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
3318 TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
3319 TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
3320 TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
3321 TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
3322 # if LDBL_MANT_DIG > 100
3323 TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
3324 TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
3325 TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
3326 # endif
3327
3328 TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
3329 TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
3330 TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
3331 TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
3332 TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
3333 # if LDBL_MANT_DIG > 100
3334 TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
3335 TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
3336 TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
3337 # endif
3338
3339 TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
3340 TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
3341 TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
3342 TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
3343 TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
3344
3345 # if LDBL_MANT_DIG > 100
3346 TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
3347 TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
3348 TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
3349 TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
3350 TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
3351 TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
3352 # endif
3353
3354 TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
3355 TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
3356 TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
3357 TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
3358 TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
3359
3360 # if LDBL_MANT_DIG > 100
3361 TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
3362 TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
3363 TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
3364 TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
3365 TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
3366 TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
3367 # endif
3368
3369 TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
3370 TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
3371 TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
3372 TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
3373 TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
3374
3375 TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
3376 TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
3377 TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
3378 TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
3379 TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
3380
3381 TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
3382 TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
3383 TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
3384 TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
3385 TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
3386 #endif
3387
3388 END (floor);
3389 }
3390
3391
3392 static void
3393 fma_test (void)
3394 {
3395 START (fma);
3396
3397 TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
3398 TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
3399 TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
3400 TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3401 TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3402 TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3403 TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3404 TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3405 TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3406 TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3407 TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3408 TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3409
3410 TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3411 TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3412 TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3413 TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3414 TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3415 TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3416 TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3417 TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
3418
3419 TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
3420
3421 FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3422 LDBL_MAX, DBL_MAX, FLT_MAX);
3423 TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
3424 TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
3425 TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
3426 TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
3427 TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
3428 TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
3429 TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
3430 TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
3431
3432 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
3433 TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
3434 TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
3435 TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
3436 TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
3437 TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
3438 TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
3439 TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
3440 #endif
3441 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
3442 TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
3443 TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
3444 TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
3445 TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
3446 TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
3447 TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
3448 TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
3449 TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
3450 TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
3451 TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0);
3452 TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022);
3453 TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022);
3454 TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022);
3455 TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022);
3456 TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022);
3457 TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022);
3458 TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022);
3459 TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022);
3460 TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022);
3461 TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
3462 #endif
3463 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
3464 TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
3465 TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
3466 TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
3467 TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
3468 TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
3469 TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L);
3470 #endif
3471 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
3472 TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
3473 TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L);
3474 TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L);
3475 TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
3476 TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
3477 TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
3478 TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
3479 TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
3480 TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
3481 TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
3482 TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
3483 TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
3484 TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
3485 #endif
3486
3487 END (fma);
3488 }
3489
3490
3491 static void
3492 fmax_test (void)
3493 {
3494 START (fmax);
3495
3496 TEST_ff_f (fmax, 0, 0, 0);
3497 TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
3498 TEST_ff_f (fmax, 9, 0, 9);
3499 TEST_ff_f (fmax, 0, 9, 9);
3500 TEST_ff_f (fmax, -9, 0, 0);
3501 TEST_ff_f (fmax, 0, -9, 0);
3502
3503 TEST_ff_f (fmax, plus_infty, 9, plus_infty);
3504 TEST_ff_f (fmax, 0, plus_infty, plus_infty);
3505 TEST_ff_f (fmax, -9, plus_infty, plus_infty);
3506 TEST_ff_f (fmax, plus_infty, -9, plus_infty);
3507
3508 TEST_ff_f (fmax, minus_infty, 9, 9);
3509 TEST_ff_f (fmax, minus_infty, -9, -9);
3510 TEST_ff_f (fmax, 9, minus_infty, 9);
3511 TEST_ff_f (fmax, -9, minus_infty, -9);
3512
3513 TEST_ff_f (fmax, 0, nan_value, 0);
3514 TEST_ff_f (fmax, 9, nan_value, 9);
3515 TEST_ff_f (fmax, -9, nan_value, -9);
3516 TEST_ff_f (fmax, nan_value, 0, 0);
3517 TEST_ff_f (fmax, nan_value, 9, 9);
3518 TEST_ff_f (fmax, nan_value, -9, -9);
3519 TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
3520 TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
3521 TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
3522 TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
3523 TEST_ff_f (fmax, nan_value, nan_value, nan_value);
3524
3525 END (fmax);
3526 }
3527
3528
3529 static void
3530 fmin_test (void)
3531 {
3532 START (fmin);
3533
3534 TEST_ff_f (fmin, 0, 0, 0);
3535 TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
3536 TEST_ff_f (fmin, 9, 0, 0);
3537 TEST_ff_f (fmin, 0, 9, 0);
3538 TEST_ff_f (fmin, -9, 0, -9);
3539 TEST_ff_f (fmin, 0, -9, -9);
3540
3541 TEST_ff_f (fmin, plus_infty, 9, 9);
3542 TEST_ff_f (fmin, 9, plus_infty, 9);
3543 TEST_ff_f (fmin, plus_infty, -9, -9);
3544 TEST_ff_f (fmin, -9, plus_infty, -9);
3545 TEST_ff_f (fmin, minus_infty, 9, minus_infty);
3546 TEST_ff_f (fmin, minus_infty, -9, minus_infty);
3547 TEST_ff_f (fmin, 9, minus_infty, minus_infty);
3548 TEST_ff_f (fmin, -9, minus_infty, minus_infty);
3549
3550 TEST_ff_f (fmin, 0, nan_value, 0);
3551 TEST_ff_f (fmin, 9, nan_value, 9);
3552 TEST_ff_f (fmin, -9, nan_value, -9);
3553 TEST_ff_f (fmin, nan_value, 0, 0);
3554 TEST_ff_f (fmin, nan_value, 9, 9);
3555 TEST_ff_f (fmin, nan_value, -9, -9);
3556 TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
3557 TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
3558 TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
3559 TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
3560 TEST_ff_f (fmin, nan_value, nan_value, nan_value);
3561
3562 END (fmin);
3563 }
3564
3565
3566 static void
3567 fmod_test (void)
3568 {
3569 errno = 0;
3570 FUNC(fmod) (6.5, 2.3L);
3571 if (errno == ENOSYS)
3572 /* Function not implemented. */
3573 return;
3574
3575 START (fmod);
3576
3577 /* fmod (+0, y) == +0 for y != 0. */
3578 TEST_ff_f (fmod, 0, 3, 0);
3579
3580 /* fmod (-0, y) == -0 for y != 0. */
3581 TEST_ff_f (fmod, minus_zero, 3, minus_zero);
3582
3583 /* fmod (+inf, y) == NaN plus invalid exception. */
3584 errno = 0;
3585 TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
3586 check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
3587 /* fmod (-inf, y) == NaN plus invalid exception. */
3588 errno = 0;
3589 TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
3590 check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
3591 /* fmod (x, +0) == NaN plus invalid exception. */
3592 errno = 0;
3593 TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
3594 check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
3595 /* fmod (x, -0) == NaN plus invalid exception. */
3596 TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
3597
3598 /* fmod (x, +inf) == x for x not infinite. */
3599 TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
3600 /* fmod (x, -inf) == x for x not infinite. */
3601 TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
3602
3603 TEST_ff_f (fmod, nan_value, nan_value, nan_value);
3604
3605 TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
3606 TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
3607 TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
3608 TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
3609
3610 END (fmod);
3611 }
3612
3613
3614 static void
3615 fpclassify_test (void)
3616 {
3617 START (fpclassify);
3618
3619 TEST_f_i (fpclassify, nan_value, FP_NAN);
3620 TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
3621 TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
3622 TEST_f_i (fpclassify, plus_zero, FP_ZERO);
3623 TEST_f_i (fpclassify, minus_zero, FP_ZERO);
3624 TEST_f_i (fpclassify, 1000, FP_NORMAL);
3625
3626 END (fpclassify);
3627 }
3628
3629
3630 static void
3631 frexp_test (void)
3632 {
3633 int x;
3634
3635 START (frexp);
3636
3637 TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
3638 TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
3639 TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
3640
3641 TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
3642 TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
3643
3644 TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
3645 TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
3646
3647 END (frexp);
3648 }
3649
3650
3651 static void
3652 gamma_test (void)
3653 {
3654 errno = 0;
3655 FUNC(gamma) (1);
3656
3657 if (errno == ENOSYS)
3658 /* Function not implemented. */
3659 return;
3660 feclearexcept (FE_ALL_EXCEPT);
3661
3662 START (gamma);
3663
3664 TEST_f_f (gamma, plus_infty, plus_infty);
3665 TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3666 TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3667 TEST_f_f (gamma, minus_infty, plus_infty);
3668 TEST_f_f (gamma, nan_value, nan_value);
3669
3670 TEST_f_f1 (gamma, 1, 0, 1);
3671 TEST_f_f1 (gamma, 3, M_LN2l, 1);
3672
3673 TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
3674 TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3675
3676 END (gamma);
3677 }
3678
3679 static void
3680 hypot_test (void)
3681 {
3682 errno = 0;
3683 FUNC(hypot) (0.7L, 12.4L);
3684 if (errno == ENOSYS)
3685 /* Function not implemented. */
3686 return;
3687
3688 START (hypot);
3689
3690 TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
3691 TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
3692
3693 #ifndef TEST_INLINE
3694 TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
3695 TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
3696 TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
3697 TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
3698 #endif
3699
3700 TEST_ff_f (hypot, nan_value, nan_value, nan_value);
3701
3702 /* hypot (x,y) == hypot (+-x, +-y) */
3703 TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
3704 TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
3705 TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
3706 TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
3707 TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
3708 TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
3709 TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
3710 TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
3711
3712 /* hypot (x,0) == fabs (x) */
3713 TEST_ff_f (hypot, 0.75L, 0, 0.75L);
3714 TEST_ff_f (hypot, -0.75L, 0, 0.75L);
3715 TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
3716
3717 TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
3718
3719 #if !(defined TEST_FLOAT && defined TEST_INLINE)
3720 TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
3721 TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
3722 #endif
3723
3724 #ifndef TEST_FLOAT
3725 TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
3726 #endif
3727
3728 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
3729 TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
3730 #endif
3731
3732 END (hypot);
3733 }
3734
3735
3736 static void
3737 ilogb_test (void)
3738 {
3739 START (ilogb);
3740
3741 TEST_f_i (ilogb, 1, 0);
3742 TEST_f_i (ilogb, M_El, 1);
3743 TEST_f_i (ilogb, 1024, 10);
3744 TEST_f_i (ilogb, -2000, 10);
3745
3746 /* XXX We have a problem here: the standard does not tell us whether
3747 exceptions are allowed/required. ignore them for now. */
3748
3749 TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
3750 TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
3751 TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
3752 TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
3753
3754 END (ilogb);
3755 }
3756
3757 static void
3758 isfinite_test (void)
3759 {
3760 START (isfinite);
3761
3762 TEST_f_b (isfinite, 0, 1);
3763 TEST_f_b (isfinite, minus_zero, 1);
3764 TEST_f_b (isfinite, 10, 1);
3765 TEST_f_b (isfinite, plus_infty, 0);
3766 TEST_f_b (isfinite, minus_infty, 0);
3767 TEST_f_b (isfinite, nan_value, 0);
3768
3769 END (isfinite);
3770 }
3771
3772 static void
3773 isnormal_test (void)
3774 {
3775 START (isnormal);
3776
3777 TEST_f_b (isnormal, 0, 0);
3778 TEST_f_b (isnormal, minus_zero, 0);
3779 TEST_f_b (isnormal, 10, 1);
3780 TEST_f_b (isnormal, plus_infty, 0);
3781 TEST_f_b (isnormal, minus_infty, 0);
3782 TEST_f_b (isnormal, nan_value, 0);
3783
3784 END (isnormal);
3785 }
3786
3787 static void
3788 j0_test (void)
3789 {
3790 FLOAT s, c;
3791 errno = 0;
3792 FUNC (sincos) (0, &s, &c);
3793 if (errno == ENOSYS)
3794 /* Required function not implemented. */
3795 return;
3796 FUNC(j0) (0);
3797 if (errno == ENOSYS)
3798 /* Function not implemented. */
3799 return;
3800
3801 START (j0);
3802
3803 /* j0 is the Bessel function of the first kind of order 0 */
3804 TEST_f_f (j0, nan_value, nan_value);
3805 TEST_f_f (j0, plus_infty, 0);
3806 TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3807 TEST_f_f (j0, 0.0, 1.0);
3808 TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3809 TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3810 TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3811 TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3812 TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3813 TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3814 TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3815 TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3816 TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3817
3818 TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L);
3819
3820 #ifndef TEST_FLOAT
3821 TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L);
3822 #endif
3823
3824 END (j0);
3825 }
3826
3827
3828 static void
3829 j1_test (void)
3830 {
3831 FLOAT s, c;
3832 errno = 0;
3833 FUNC (sincos) (0, &s, &c);
3834 if (errno == ENOSYS)
3835 /* Required function not implemented. */
3836 return;
3837 FUNC(j1) (0);
3838 if (errno == ENOSYS)
3839 /* Function not implemented. */
3840 return;
3841
3842 /* j1 is the Bessel function of the first kind of order 1 */
3843
3844 START (j1);
3845
3846 TEST_f_f (j1, nan_value, nan_value);
3847 TEST_f_f (j1, plus_infty, 0);
3848
3849 TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3850 TEST_f_f (j1, 0.0, 0.0);
3851 TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3852 TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3853 TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3854 TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3855 TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3856 TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3857 TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3858
3859 TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
3860
3861 #ifndef TEST_FLOAT
3862 TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
3863 #endif
3864
3865 END (j1);
3866 }
3867
3868 static void
3869 jn_test (void)
3870 {
3871 FLOAT s, c;
3872 errno = 0;
3873 FUNC (sincos) (0, &s, &c);
3874 if (errno == ENOSYS)
3875 /* Required function not implemented. */
3876 return;
3877 FUNC(jn) (1, 1);
3878 if (errno == ENOSYS)
3879 /* Function not implemented. */
3880 return;
3881
3882 /* jn is the Bessel function of the first kind of order n. */
3883 START (jn);
3884
3885 /* jn (0, x) == j0 (x) */
3886 TEST_ff_f (jn, 0, nan_value, nan_value);
3887 TEST_ff_f (jn, 0, plus_infty, 0);
3888 TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3889 TEST_ff_f (jn, 0, 0.0, 1.0);
3890 TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3891 TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3892 TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3893 TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3894 TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3895 TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3896 TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3897 TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3898 TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3899
3900 /* jn (1, x) == j1 (x) */
3901 TEST_ff_f (jn, 1, nan_value, nan_value);
3902 TEST_ff_f (jn, 1, plus_infty, 0);
3903 TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3904 TEST_ff_f (jn, 1, 0.0, 0.0);
3905 TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3906 TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3907 TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3908 TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3909 TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3910 TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3911 TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3912
3913 /* jn (3, x) */
3914 TEST_ff_f (jn, 3, nan_value, nan_value);
3915 TEST_ff_f (jn, 3, plus_infty, 0);
3916
3917 TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3918 TEST_ff_f (jn, 3, 0.0, 0.0);
3919 TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3920 TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3921 TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3922 TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3923 TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3924
3925 /* jn (10, x) */
3926 TEST_ff_f (jn, 10, nan_value, nan_value);
3927 TEST_ff_f (jn, 10, plus_infty, 0);
3928
3929 TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3930 TEST_ff_f (jn, 10, 0.0, 0.0);
3931 TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3932 TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3933 TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3934 TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3935 TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3936
3937 /* BZ #11589 .*/
3938 TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
3939 TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
3940 TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
3941 TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
3942 TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
3943 TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
3944 TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
3945 TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
3946
3947 TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L);
3948
3949 END (jn);
3950 }
3951
3952
3953 static void
3954 ldexp_test (void)
3955 {
3956 TEST_ff_f (ldexp, 0, 0, 0);
3957 TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3958
3959 TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3960 TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3961 TEST_ff_f (ldexp, nan_value, 1, nan_value);
3962
3963 TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3964 TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3965
3966 /* ldexp (x, 0) == x. */
3967 TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3968 }
3969
3970
3971 static void
3972 lgamma_test (void)
3973 {
3974 errno = 0;
3975 FUNC(lgamma) (0);
3976 if (errno == ENOSYS)
3977 /* Function not implemented. */
3978 return;
3979 feclearexcept (FE_ALL_EXCEPT);
3980
3981 START (lgamma);
3982
3983 TEST_f_f (lgamma, plus_infty, plus_infty);
3984 TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3985 check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
3986 TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3987 check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
3988 TEST_f_f (lgamma, nan_value, nan_value);
3989
3990 /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0. */
3991 errno = 0;
3992 TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3993 check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
3994 TEST_f_f (lgamma, minus_infty, plus_infty);
3995 TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3996 TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
3997
3998 TEST_f_f1 (lgamma, 1, 0, 1);
3999
4000 TEST_f_f1 (lgamma, 3, M_LN2l, 1);
4001
4002 TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
4003 TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
4004 TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
4005 TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
4006
4007 END (lgamma);
4008 }
4009
4010
4011 static void
4012 lrint_test (void)
4013 {
4014 /* XXX this test is incomplete. We need to have a way to specifiy
4015 the rounding method and test the critical cases. So far, only
4016 unproblematic numbers are tested. */
4017
4018 START (lrint);
4019
4020 TEST_f_l (lrint, 0.0, 0);
4021 TEST_f_l (lrint, minus_zero, 0);
4022 TEST_f_l (lrint, 0.2L, 0);
4023 TEST_f_l (lrint, -0.2L, 0);
4024
4025 TEST_f_l (lrint, 1.4L, 1);
4026 TEST_f_l (lrint, -1.4L, -1);
4027
4028 TEST_f_l (lrint, 8388600.3L, 8388600);
4029 TEST_f_l (lrint, -8388600.3L, -8388600);
4030
4031 TEST_f_l (lrint, 1071930.0008, 1071930);
4032 #ifndef TEST_FLOAT
4033 TEST_f_l (lrint, 1073741824.01, 1073741824);
4034 # if LONG_MAX > 281474976710656
4035 TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4036 # endif
4037 #endif
4038
4039 END (lrint);
4040 }
4041
4042
4043 static void
4044 lrint_test_tonearest (void)
4045 {
4046 int save_round_mode;
4047 START (lrint_tonearest);
4048
4049 save_round_mode = fegetround ();
4050
4051 if (!fesetround (FE_TONEAREST))
4052 {
4053 TEST_f_l (lrint, 0.0, 0);
4054 TEST_f_l (lrint, minus_zero, 0);
4055 TEST_f_l (lrint, 0.2L, 0);
4056 TEST_f_l (lrint, -0.2L, 0);
4057 TEST_f_l (lrint, 0.5L, 0);
4058 TEST_f_l (lrint, -0.5L, 0);
4059 TEST_f_l (lrint, 0.8L, 1);
4060 TEST_f_l (lrint, -0.8L, -1);
4061
4062 TEST_f_l (lrint, 1.4L, 1);
4063 TEST_f_l (lrint, -1.4L, -1);
4064
4065 TEST_f_l (lrint, 8388600.3L, 8388600);
4066 TEST_f_l (lrint, -8388600.3L, -8388600);
4067
4068 TEST_f_l (lrint, 1071930.0008, 1071930);
4069 #ifndef TEST_FLOAT
4070 TEST_f_l (lrint, 1073741824.01, 1073741824);
4071 # if LONG_MAX > 281474976710656
4072 TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4073 # endif
4074 #endif
4075 }
4076
4077 fesetround (save_round_mode);
4078
4079 END (lrint_tonearest);
4080 }
4081
4082
4083 static void
4084 lrint_test_towardzero (void)
4085 {
4086 int save_round_mode;
4087 START (lrint_towardzero);
4088
4089 save_round_mode = fegetround ();
4090
4091 if (!fesetround (FE_TOWARDZERO))
4092 {
4093 TEST_f_l (lrint, 0.0, 0);
4094 TEST_f_l (lrint, minus_zero, 0);
4095 TEST_f_l (lrint, 0.2L, 0);
4096 TEST_f_l (lrint, -0.2L, 0);
4097 TEST_f_l (lrint, 0.5L, 0);
4098 TEST_f_l (lrint, -0.5L, 0);
4099 TEST_f_l (lrint, 0.8L, 0);
4100 TEST_f_l (lrint, -0.8L, 0);
4101
4102 TEST_f_l (lrint, 1.4L, 1);
4103 TEST_f_l (lrint, -1.4L, -1);
4104
4105 TEST_f_l (lrint, 8388600.3L, 8388600);
4106 TEST_f_l (lrint, -8388600.3L, -8388600);
4107
4108 TEST_f_l (lrint, 1071930.0008, 1071930);
4109 #ifndef TEST_FLOAT
4110 TEST_f_l (lrint, 1073741824.01, 1073741824);
4111 # if LONG_MAX > 281474976710656
4112 TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4113 # endif
4114 #endif
4115 }
4116
4117 fesetround (save_round_mode);
4118
4119 END (lrint_towardzero);
4120 }
4121
4122
4123 static void
4124 lrint_test_downward (void)
4125 {
4126 int save_round_mode;
4127 START (lrint_downward);
4128
4129 save_round_mode = fegetround ();
4130
4131 if (!fesetround (FE_DOWNWARD))
4132 {
4133 TEST_f_l (lrint, 0.0, 0);
4134 TEST_f_l (lrint, minus_zero, 0);
4135 TEST_f_l (lrint, 0.2L, 0);
4136 TEST_f_l (lrint, -0.2L, -1);
4137 TEST_f_l (lrint, 0.5L, 0);
4138 TEST_f_l (lrint, -0.5L, -1);
4139 TEST_f_l (lrint, 0.8L, 0);
4140 TEST_f_l (lrint, -0.8L, -1);
4141
4142 TEST_f_l (lrint, 1.4L, 1);
4143 TEST_f_l (lrint, -1.4L, -2);
4144
4145 TEST_f_l (lrint, 8388600.3L, 8388600);
4146 TEST_f_l (lrint, -8388600.3L, -8388601);
4147
4148 TEST_f_l (lrint, 1071930.0008, 1071930);
4149 #ifndef TEST_FLOAT
4150 TEST_f_l (lrint, 1073741824.01, 1073741824);
4151 # if LONG_MAX > 281474976710656
4152 TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4153 # endif
4154 #endif
4155 }
4156
4157 fesetround (save_round_mode);
4158
4159 END (lrint_downward);
4160 }
4161
4162
4163 static void
4164 lrint_test_upward (void)
4165 {
4166 int save_round_mode;
4167 START (lrint_upward);
4168
4169 save_round_mode = fegetround ();
4170
4171 if (!fesetround (FE_UPWARD))
4172 {
4173 TEST_f_l (lrint, 0.0, 0);
4174 TEST_f_l (lrint, minus_zero, 0);
4175 TEST_f_l (lrint, 0.2L, 1);
4176 TEST_f_l (lrint, -0.2L, 0);
4177 TEST_f_l (lrint, 0.5L, 1);
4178 TEST_f_l (lrint, -0.5L, 0);
4179 TEST_f_l (lrint, 0.8L, 1);
4180 TEST_f_l (lrint, -0.8L, 0);
4181
4182 TEST_f_l (lrint, 1.4L, 2);
4183 TEST_f_l (lrint, -1.4L, -1);
4184
4185 TEST_f_l (lrint, 8388600.3L, 8388601);
4186 TEST_f_l (lrint, -8388600.3L, -8388600);
4187
4188 #ifndef TEST_FLOAT
4189 TEST_f_l (lrint, 1071930.0008, 1071931);
4190 TEST_f_l (lrint, 1073741824.01, 1073741825);
4191 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
4192 TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4193 # endif
4194 #endif
4195 }
4196
4197 fesetround (save_round_mode);
4198
4199 END (lrint_upward);
4200 }
4201
4202
4203 static void
4204 llrint_test (void)
4205 {
4206 /* XXX this test is incomplete. We need to have a way to specifiy
4207 the rounding method and test the critical cases. So far, only
4208 unproblematic numbers are tested. */
4209
4210 START (llrint);
4211
4212 TEST_f_L (llrint, 0.0, 0);
4213 TEST_f_L (llrint, minus_zero, 0);
4214 TEST_f_L (llrint, 0.2L, 0);
4215 TEST_f_L (llrint, -0.2L, 0);
4216
4217 TEST_f_L (llrint, 1.4L, 1);
4218 TEST_f_L (llrint, -1.4L, -1);
4219
4220 TEST_f_L (llrint, 8388600.3L, 8388600);
4221 TEST_f_L (llrint, -8388600.3L, -8388600);
4222
4223 TEST_f_l (llrint, 1071930.0008, 1071930);
4224
4225 /* Test boundary conditions. */
4226 /* 0x1FFFFF */
4227 TEST_f_L (llrint, 2097151.0,2097151LL);
4228 /* 0x800000 */
4229 TEST_f_L (llrint, 8388608.0, 8388608LL);
4230 /* 0x1000000 */
4231 TEST_f_L (llrint, 16777216.0, 16777216LL);
4232 /* 0x20000000000 */
4233 TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4234 /* 0x40000000000 */
4235 TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4236 /* 0x1000000000000 */
4237 TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4238 /* 0x10000000000000 */
4239 TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4240 /* 0x10000080000000 */
4241 TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4242 /* 0x20000000000000 */
4243 TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4244 /* 0x80000000000000 */
4245 TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4246 /* 0x100000000000000 */
4247 TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4248 #ifdef TEST_LDOUBLE
4249 /* The input can only be represented in long double. */
4250 TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4251 TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4252 TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4253 TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4254 TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4255
4256 TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4257 TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4258 TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4259 TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4260 TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4261
4262 # if LDBL_MANT_DIG > 100
4263 TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4264 TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4265 TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4266 TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4267 TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4268 TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4269
4270 TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4271 TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4272 TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4273 TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4274 TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4275 TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4276 #endif
4277
4278 TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4279 TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4280 TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4281 TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4282 TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4283
4284 TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4285 TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4286 TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4287 TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4288 TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4289
4290 # if LDBL_MANT_DIG > 100
4291 TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4292 TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4293 TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4294 TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4295 TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4296 TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4297
4298 TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4299 TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4300 TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4301 TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4302 TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4303 TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4304 #endif
4305
4306 TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4307 TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4308 TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4309 TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4310 TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4311
4312 TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4313 TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4314 TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4315 TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4316 TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4317
4318 # if LDBL_MANT_DIG > 100
4319 TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4320 TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4321 TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4322 TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4323 TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4324 TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4325 TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4326 TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4327 TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4328 TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4329 TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4330 TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4331 # endif
4332 #endif
4333
4334 END (llrint);
4335 }
4336
4337 static void
4338 llrint_test_tonearest (void)
4339 {
4340 int save_round_mode;
4341 START (llrint_tonearest);
4342
4343 save_round_mode = fegetround ();
4344
4345 if (!fesetround (FE_TONEAREST))
4346 {
4347 TEST_f_L (llrint, 0.0, 0);
4348 TEST_f_L (llrint, minus_zero, 0);
4349 TEST_f_L (llrint, 0.2L, 0);
4350 TEST_f_L (llrint, -0.2L, 0);
4351
4352 TEST_f_L (llrint, 1.4L, 1);
4353 TEST_f_L (llrint, -1.4L, -1);
4354
4355 TEST_f_L (llrint, 8388600.3L, 8388600);
4356 TEST_f_L (llrint, -8388600.3L, -8388600);
4357
4358 TEST_f_l (llrint, 1071930.0008, 1071930);
4359
4360 /* Test boundary conditions. */
4361 /* 0x1FFFFF */
4362 TEST_f_L (llrint, 2097151.0,2097151LL);
4363 /* 0x800000 */
4364 TEST_f_L (llrint, 8388608.0, 8388608LL);
4365 /* 0x1000000 */
4366 TEST_f_L (llrint, 16777216.0, 16777216LL);
4367 /* 0x20000000000 */
4368 TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4369 /* 0x40000000000 */
4370 TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4371 /* 0x1000000000000 */
4372 TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4373 /* 0x10000000000000 */
4374 TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4375 /* 0x10000080000000 */
4376 TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4377 /* 0x20000000000000 */
4378 TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4379 /* 0x80000000000000 */
4380 TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4381 /* 0x100000000000000 */
4382 TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4383 #ifdef TEST_LDOUBLE
4384 /* The input can only be represented in long double. */
4385 TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4386 TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4387 TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4388 TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4389 TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4390
4391 TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4392 TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4393 TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4394 TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4395 TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4396
4397 # if LDBL_MANT_DIG > 100
4398 TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4399 TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4400 TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4401 TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4402 TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4403 TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4404
4405 TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4406 TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4407 TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4408 TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4409 TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4410 TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4411 #endif
4412
4413 TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4414 TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4415 TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4416 TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4417 TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4418
4419 TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4420 TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4421 TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4422 TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4423 TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4424
4425 # if LDBL_MANT_DIG > 100
4426 TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4427 TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4428 TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4429 TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4430 TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4431 TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4432
4433 TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4434 TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4435 TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4436 TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4437 TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4438 TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4439 #endif
4440
4441 TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4442 TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4443 TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4444 TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4445 TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4446
4447 TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4448 TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4449 TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4450 TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4451 TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4452
4453 # if LDBL_MANT_DIG > 100
4454 TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4455 TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4456 TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4457 TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4458 TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4459 TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4460 TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4461 TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4462 TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4463 TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4464 TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4465 TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4466 # endif
4467 #endif
4468 }
4469
4470 fesetround (save_round_mode);
4471
4472 END (llrint_tonearest);
4473 }
4474
4475 static void
4476 llrint_test_towardzero (void)
4477 {
4478 int save_round_mode;
4479 START (llrint_towardzero);
4480
4481 save_round_mode = fegetround ();
4482
4483 if (!fesetround (FE_TOWARDZERO))
4484 {
4485 TEST_f_L (llrint, 0.0, 0);
4486 TEST_f_L (llrint, minus_zero, 0);
4487 TEST_f_L (llrint, 0.2L, 0);
4488 TEST_f_L (llrint, -0.2L, 0);
4489
4490 TEST_f_L (llrint, 1.4L, 1);
4491 TEST_f_L (llrint, -1.4L, -1);
4492
4493 TEST_f_L (llrint, 8388600.3L, 8388600);
4494 TEST_f_L (llrint, -8388600.3L, -8388600);
4495
4496 TEST_f_l (llrint, 1071930.0008, 1071930);
4497
4498 /* Test boundary conditions. */
4499 /* 0x1FFFFF */
4500 TEST_f_L (llrint, 2097151.0,2097151LL);
4501 /* 0x800000 */
4502 TEST_f_L (llrint, 8388608.0, 8388608LL);
4503 /* 0x1000000 */
4504 TEST_f_L (llrint, 16777216.0, 16777216LL);
4505 /* 0x20000000000 */
4506 TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4507 /* 0x40000000000 */
4508 TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4509 /* 0x1000000000000 */
4510 TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4511 /* 0x10000000000000 */
4512 TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4513 /* 0x10000080000000 */
4514 TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4515 /* 0x20000000000000 */
4516 TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4517 /* 0x80000000000000 */
4518 TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4519 /* 0x100000000000000 */
4520 TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4521 #ifdef TEST_LDOUBLE
4522 /* The input can only be represented in long double. */
4523 TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
4524 TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4525 TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4526 TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
4527 TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
4528
4529 TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4530 TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4531 TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4532 TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4533 TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4534
4535 # if LDBL_MANT_DIG > 100
4536 TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4537 TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4538 TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4539 TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
4540 TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
4541 TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
4542
4543 TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4544 TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4545 TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4546 TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4547 TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4548 TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4549 #endif
4550
4551 TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
4552 TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4553 TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4554 TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
4555 TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
4556
4557 TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4558 TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4559 TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4560 TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4561 TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4562
4563 # if LDBL_MANT_DIG > 100
4564 TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4565 TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4566 TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4567 TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
4568 TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
4569 TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
4570
4571 TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4572 TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4573 TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4574 TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4575 TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4576 TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4577 #endif
4578
4579 TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
4580 TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4581 TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4582 TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
4583 TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
4584
4585 TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4586 TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4587 TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4588 TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4589 TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4590
4591 # if LDBL_MANT_DIG > 100
4592 TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
4593 TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4594 TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4595 TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4596 TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4597 TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4598 TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4599 TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4600 TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
4601 TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4602 TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4603 TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4604 # endif
4605 #endif
4606 }
4607
4608 fesetround (save_round_mode);
4609
4610 END (llrint_towardzero);
4611 }
4612
4613 static void
4614 llrint_test_downward (void)
4615 {
4616 int save_round_mode;
4617 START (llrint_downward);
4618
4619 save_round_mode = fegetround ();
4620
4621 if (!fesetround (FE_DOWNWARD))
4622 {
4623 TEST_f_L (llrint, 0.0, 0);
4624 TEST_f_L (llrint, minus_zero, 0);
4625 TEST_f_L (llrint, 0.2L, 0);
4626 TEST_f_L (llrint, -0.2L, -1);
4627
4628 TEST_f_L (llrint, 1.4L, 1);
4629 TEST_f_L (llrint, -1.4L, -2);
4630
4631 TEST_f_L (llrint, 8388600.3L, 8388600);
4632 TEST_f_L (llrint, -8388600.3L, -8388601);
4633
4634 TEST_f_l (llrint, 1071930.0008, 1071930);
4635
4636 /* Test boundary conditions. */
4637 /* 0x1FFFFF */
4638 TEST_f_L (llrint, 2097151.0,2097151LL);
4639 /* 0x800000 */
4640 TEST_f_L (llrint, 8388608.0, 8388608LL);
4641 /* 0x1000000 */
4642 TEST_f_L (llrint, 16777216.0, 16777216LL);
4643 /* 0x20000000000 */
4644 TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4645 /* 0x40000000000 */
4646 TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4647 /* 0x1000000000000 */
4648 TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4649 /* 0x10000000000000 */
4650 TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4651 /* 0x10000080000000 */
4652 TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4653 /* 0x20000000000000 */
4654 TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4655 /* 0x80000000000000 */
4656 TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4657 /* 0x100000000000000 */
4658 TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4659 #ifdef TEST_LDOUBLE
4660 /* The input can only be represented in long double. */
4661 TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
4662 TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4663 TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4664 TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
4665 TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
4666
4667 TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4668 TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4669 TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4670 TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
4671 TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
4672 TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
4673
4674 TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4675 TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
4676 TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
4677 TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4678 TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4679
4680 TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
4681 TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
4682 TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
4683 TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4684 TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4685 TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4686
4687 TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
4688 TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4689 TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4690 TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
4691 TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
4692
4693 TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4694 TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4695 TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4696 TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
4697 TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
4698 TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
4699
4700 TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4701 TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
4702 TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
4703 TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4704 TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4705
4706 TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
4707 TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
4708 TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
4709 TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4710 TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4711 TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4712
4713 TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
4714 TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4715 TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4716 TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
4717 TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
4718
4719 TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4720 TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
4721 TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
4722 TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4723 TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4724
4725 # if LDBL_MANT_DIG > 100
4726 TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
4727 TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4728 TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4729 TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4730 TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4731 TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
4732 TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4733 TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
4734 TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
4735 TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4736 TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4737 TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4738 # endif
4739 #endif
4740 }
4741
4742 fesetround (save_round_mode);
4743
4744 END (llrint_downward);
4745 }
4746
4747 static void
4748 llrint_test_upward (void)
4749 {
4750 int save_round_mode;
4751 START (llrint_upward);
4752
4753 save_round_mode = fegetround ();
4754
4755 if (!fesetround (FE_UPWARD))
4756 {
4757 TEST_f_L (llrint, 0.0, 0);
4758 TEST_f_L (llrint, minus_zero, 0);
4759 TEST_f_L (llrint, 0.2L, 1);
4760 TEST_f_L (llrint, -0.2L, 0);
4761
4762 TEST_f_L (llrint, 1.4L, 2);
4763 TEST_f_L (llrint, -1.4L, -1);
4764
4765 TEST_f_L (llrint, 8388600.3L, 8388601);
4766 TEST_f_L (llrint, -8388600.3L, -8388600);
4767 #ifndef TEST_FLOAT
4768 TEST_f_l (llrint, 1071930.0008, 1071931);
4769 #endif
4770 /* Test boundary conditions. */
4771 /* 0x1FFFFF */
4772 TEST_f_L (llrint, 2097151.0,2097151LL);
4773 /* 0x800000 */
4774 TEST_f_L (llrint, 8388608.0, 8388608LL);
4775 /* 0x1000000 */
4776 TEST_f_L (llrint, 16777216.0, 16777216LL);
4777 /* 0x20000000000 */
4778 TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4779 /* 0x40000000000 */
4780 TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4781 /* 0x1000000000000 */
4782 TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4783 /* 0x10000000000000 */
4784 TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4785 /* 0x10000080000000 */
4786 TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4787 /* 0x20000000000000 */
4788 TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4789 /* 0x80000000000000 */
4790 TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4791 /* 0x100000000000000 */
4792 TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4793 #ifdef TEST_LDOUBLE
4794 /* The input can only be represented in long double. */
4795 TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4796 TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
4797 TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
4798 TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4799 TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4800
4801 TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
4802 TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
4803 TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
4804 TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4805 TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4806 TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4807
4808 TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4809 TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4810 TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4811 TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4812 TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4813
4814 TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4815 TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4816 TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4817 TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4818 TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4819 TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4820
4821 TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4822 TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
4823 TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
4824 TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4825 TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4826
4827 TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
4828 TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
4829 TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
4830 TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4831 TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4832 TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4833
4834 TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4835 TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4836 TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4837 TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4838 TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4839
4840 TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4841 TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4842 TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4843 TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4844 TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4845 TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4846
4847 TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4848 TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
4849 TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
4850 TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4851 TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4852
4853 TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4854 TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4855 TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4856 TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4857 TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4858
4859 # if LDBL_MANT_DIG > 100
4860 TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4861 TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4862 TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4863 TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4864 TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
4865 TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4866 TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
4867 TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4868 TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4869 TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4870 TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4871 TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4872 # endif
4873 #endif
4874 }
4875
4876 fesetround (save_round_mode);
4877
4878 END (llrint_upward);
4879 }
4880
4881
4882 static void
4883 log_test (void)
4884 {
4885 errno = 0;
4886 FUNC(log) (1);
4887 if (errno == ENOSYS)
4888 /* Function not implemented. */
4889 return;
4890 START (log);
4891
4892 TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4893 TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4894
4895 TEST_f_f (log, 1, 0);
4896
4897 TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
4898 TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
4899 TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
4900 TEST_f_f (log, plus_infty, plus_infty);
4901 TEST_f_f (log, nan_value, nan_value);
4902
4903 TEST_f_f (log, M_El, 1);
4904 TEST_f_f (log, 1.0 / M_El, -1);
4905 TEST_f_f (log, 2, M_LN2l);
4906 TEST_f_f (log, 10, M_LN10l);
4907 TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
4908
4909 END (log);
4910 }
4911
4912
4913 static void
4914 log10_test (void)
4915 {
4916 errno = 0;
4917 FUNC(log10) (1);
4918 if (errno == ENOSYS)
4919 /* Function not implemented. */
4920 return;
4921
4922 START (log10);
4923
4924 TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4925 TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4926
4927 TEST_f_f (log10, 1, 0);
4928
4929 /* log10 (x) == NaN plus invalid exception if x < 0. */
4930 TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
4931 TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
4932 TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
4933
4934 TEST_f_f (log10, plus_infty, plus_infty);
4935 TEST_f_f (log10, nan_value, nan_value);
4936
4937 TEST_f_f (log10, 0.1L, -1);
4938 TEST_f_f (log10, 10.0, 1);
4939 TEST_f_f (log10, 100.0, 2);
4940 TEST_f_f (log10, 10000.0, 4);
4941 TEST_f_f (log10, M_El, M_LOG10El);
4942 TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
4943
4944 END (log10);
4945 }
4946
4947
4948 static void
4949 log1p_test (void)
4950 {
4951 errno = 0;
4952 FUNC(log1p) (0);
4953 if (errno == ENOSYS)
4954 /* Function not implemented. */
4955 return;
4956
4957 START (log1p);
4958
4959 TEST_f_f (log1p, 0, 0);
4960 TEST_f_f (log1p, minus_zero, minus_zero);
4961
4962 TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4963 TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
4964 TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
4965 TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
4966
4967 TEST_f_f (log1p, plus_infty, plus_infty);
4968 TEST_f_f (log1p, nan_value, nan_value);
4969
4970 TEST_f_f (log1p, M_El - 1.0, 1);
4971
4972 TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
4973 TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
4974
4975 END (log1p);
4976 }
4977
4978
4979 static void
4980 log2_test (void)
4981 {
4982 errno = 0;
4983 FUNC(log2) (1);
4984 if (errno == ENOSYS)
4985 /* Function not implemented. */
4986 return;
4987
4988 START (log2);
4989
4990 TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4991 TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4992
4993 TEST_f_f (log2, 1, 0);
4994
4995 TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
4996 TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
4997 TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
4998
4999 TEST_f_f (log2, plus_infty, plus_infty);
5000 TEST_f_f (log2, nan_value, nan_value);
5001
5002 TEST_f_f (log2, M_El, M_LOG2El);
5003 TEST_f_f (log2, 2.0, 1);
5004 TEST_f_f (log2, 16.0, 4);
5005 TEST_f_f (log2, 256.0, 8);
5006 TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
5007
5008 END (log2);
5009 }
5010
5011
5012 static void
5013 logb_test (void)
5014 {
5015 START (logb);
5016
5017 TEST_f_f (logb, plus_infty, plus_infty);
5018 TEST_f_f (logb, minus_infty, plus_infty);
5019
5020 TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5021
5022 TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5023 TEST_f_f (logb, nan_value, nan_value);
5024
5025 TEST_f_f (logb, 1, 0);
5026 TEST_f_f (logb, M_El, 1);
5027 TEST_f_f (logb, 1024, 10);
5028 TEST_f_f (logb, -2000, 10);
5029
5030 END (logb);
5031 }
5032
5033
5034 static void
5035 lround_test (void)
5036 {
5037 START (lround);
5038
5039 TEST_f_l (lround, 0, 0);
5040 TEST_f_l (lround, minus_zero, 0);
5041 TEST_f_l (lround, 0.2L, 0.0);
5042 TEST_f_l (lround, -0.2L, 0);
5043 TEST_f_l (lround, 0.5, 1);
5044 TEST_f_l (lround, -0.5, -1);
5045 TEST_f_l (lround, 0.8L, 1);
5046 TEST_f_l (lround, -0.8L, -1);
5047 TEST_f_l (lround, 1.5, 2);
5048 TEST_f_l (lround, -1.5, -2);
5049 TEST_f_l (lround, 22514.5, 22515);
5050 TEST_f_l (lround, -22514.5, -22515);
5051 TEST_f_l (lround, 1071930.0008, 1071930);
5052 #ifndef TEST_FLOAT
5053 TEST_f_l (lround, 1073741824.01, 1073741824);
5054 # if LONG_MAX > 281474976710656
5055 TEST_f_l (lround, 281474976710656.025, 281474976710656);
5056 TEST_f_l (lround, 18014398509481974, 18014398509481974);
5057 # endif
5058 TEST_f_l (lround, 2097152.5, 2097153);
5059 TEST_f_l (lround, -2097152.5, -2097153);
5060 /* nextafter(0.5,-1) */
5061 TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
5062 /* nextafter(-0.5,1) */
5063 TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
5064 #else
5065 /* nextafter(0.5,-1) */
5066 TEST_f_l (lround, 0x1.fffffp-2, 0);
5067 /* nextafter(-0.5,1) */
5068 TEST_f_l (lround, -0x1.fffffp-2, 0);
5069 TEST_f_l (lround, 0x1.fffffep+23, 16777215);
5070 TEST_f_l (lround, -0x1.fffffep+23, -16777215);
5071 #endif
5072 END (lround);
5073 }
5074
5075
5076 static void
5077 llround_test (void)
5078 {
5079 START (llround);
5080
5081 TEST_f_L (llround, 0, 0);
5082 TEST_f_L (llround, minus_zero, 0);
5083 TEST_f_L (llround, 0.2L, 0.0);
5084 TEST_f_L (llround, -0.2L, 0);
5085 TEST_f_L (llround, 0.5, 1);
5086 TEST_f_L (llround, -0.5, -1);
5087 TEST_f_L (llround, 0.8L, 1);
5088 TEST_f_L (llround, -0.8L, -1);
5089 TEST_f_L (llround, 1.5, 2);
5090 TEST_f_L (llround, -1.5, -2);
5091 TEST_f_L (llround, 22514.5, 22515);
5092 TEST_f_L (llround, -22514.5, -22515);
5093 TEST_f_l (llround, 1071930.0008, 1071930);
5094 #ifndef TEST_FLOAT
5095 TEST_f_L (llround, 2097152.5, 2097153);
5096 TEST_f_L (llround, -2097152.5, -2097153);
5097 TEST_f_L (llround, 34359738368.5, 34359738369ll);
5098 TEST_f_L (llround, -34359738368.5, -34359738369ll);
5099 TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
5100 #endif
5101
5102 /* Test boundary conditions. */
5103 /* 0x1FFFFF */
5104 TEST_f_L (llround, 2097151.0, 2097151LL);
5105 /* 0x800000 */
5106 TEST_f_L (llround, 8388608.0, 8388608LL);
5107 /* 0x1000000 */
5108 TEST_f_L (llround, 16777216.0, 16777216LL);
5109 /* 0x20000000000 */
5110 TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
5111 /* 0x40000000000 */
5112 TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
5113 /* 0x1000000000000 */
5114 TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
5115 /* 0x10000000000000 */
5116 TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
5117 /* 0x10000080000000 */
5118 TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
5119 /* 0x20000000000000 */
5120 TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
5121 /* 0x80000000000000 */
5122 TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
5123 /* 0x100000000000000 */
5124 TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
5125
5126 #ifndef TEST_FLOAT
5127 /* 0x100000000 */
5128 TEST_f_L (llround, 4294967295.5, 4294967296LL);
5129 /* 0x200000000 */
5130 TEST_f_L (llround, 8589934591.5, 8589934592LL);
5131
5132 /* nextafter(0.5,-1) */
5133 TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
5134 /* nextafter(-0.5,1) */
5135 TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
5136 /* On PowerPC an exponent of '52' is the largest incrementally
5137 * representable sequence of whole-numbers in the 'double' range. We test
5138 * lround to make sure that a guard bit set during the lround operation
5139 * hasn't forced an erroneous shift giving us an incorrect result. The odd
5140 * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
5141 * rightmost bit set. */
5142 /* +-(2^52+1) */
5143 TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
5144 TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
5145 /* +-(2^53-1): Input is the last (positive and negative) incrementally
5146 * representable whole-number in the 'double' range that might round
5147 * erroneously. */
5148 TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
5149 TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
5150 #else
5151 /* nextafter(0.5,-1) */
5152 TEST_f_L (llround, 0x1.fffffep-2, 0);
5153 /* nextafter(-0.5,1) */
5154 TEST_f_L (llround, -0x1.fffffep-2, 0);
5155 /* As above, on PowerPC an exponent of '23' is the largest incrementally
5156 * representable sequence of whole-numbers in the 'float' range.
5157 * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected. */
5158 TEST_f_L (llround, 0x1.000002p+23,8388609);
5159 TEST_f_L (llround, -0x1.000002p+23,-8388609);
5160 TEST_f_L (llround, 0x1.fffffep+23, 16777215);
5161 TEST_f_L (llround, -0x1.fffffep+23, -16777215);
5162 #endif
5163
5164
5165 #ifdef TEST_LDOUBLE
5166 /* The input can only be represented in long double. */
5167 TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
5168 TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
5169 TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
5170 TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
5171 TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
5172
5173 # if LDBL_MANT_DIG > 100
5174 TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
5175 TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
5176 TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
5177 TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
5178 TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
5179 TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
5180
5181 TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
5182 TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
5183 TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
5184 TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
5185 TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
5186 TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
5187 # endif
5188
5189 TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
5190 TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
5191 TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
5192 TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
5193 TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
5194
5195 TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
5196 TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
5197 TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
5198 TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
5199 TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
5200
5201 # if LDBL_MANT_DIG > 100
5202 TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
5203 TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
5204 TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
5205 TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
5206 TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
5207 TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
5208
5209 TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
5210 TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
5211 TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
5212 TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
5213 TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
5214 TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
5215 # endif
5216
5217 TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
5218 TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
5219 TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
5220 TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
5221 TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
5222
5223 TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
5224 TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
5225 TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
5226 TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
5227 TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
5228
5229 TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
5230 TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
5231 TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
5232 TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
5233 TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
5234
5235 TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
5236 TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
5237 TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
5238 TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
5239 TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
5240 TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
5241 #endif
5242
5243 END (llround);
5244 }
5245
5246 static void
5247 modf_test (void)
5248 {
5249 FLOAT x;
5250
5251 START (modf);
5252
5253 TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
5254 TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
5255 TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
5256 TEST_fF_f1 (modf, 0, 0, 0);
5257 TEST_fF_f1 (modf, 1.5, 0.5, 1);
5258 TEST_fF_f1 (modf, 2.5, 0.5, 2);
5259 TEST_fF_f1 (modf, -2.5, -0.5, -2);
5260 TEST_fF_f1 (modf, 20, 0, 20);
5261 TEST_fF_f1 (modf, 21, 0, 21);
5262 TEST_fF_f1 (modf, 89.5, 0.5, 89);
5263
5264 END (modf);
5265 }
5266
5267
5268 static void
5269 nearbyint_test (void)
5270 {
5271 START (nearbyint);
5272
5273 TEST_f_f (nearbyint, 0.0, 0.0);
5274 TEST_f_f (nearbyint, minus_zero, minus_zero);
5275 TEST_f_f (nearbyint, plus_infty, plus_infty);
5276 TEST_f_f (nearbyint, minus_infty, minus_infty);
5277 TEST_f_f (nearbyint, nan_value, nan_value);
5278
5279 /* Subnormal values */
5280 TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
5281 TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
5282
5283 /* Default rounding mode is round to nearest. */
5284 TEST_f_f (nearbyint, 0.5, 0.0);
5285 TEST_f_f (nearbyint, 1.5, 2.0);
5286 TEST_f_f (nearbyint, -0.5, minus_zero);
5287 TEST_f_f (nearbyint, -1.5, -2.0);
5288
5289 TEST_f_f (nearbyint, 262144.75, 262145.0);
5290 TEST_f_f (nearbyint, 262142.75, 262143.0);
5291 TEST_f_f (nearbyint, 524286.75, 524287.0);
5292 TEST_f_f (nearbyint, 524288.75, 524289.0);
5293
5294 TEST_f_f (nearbyint, 1048576.75, 1048577.0);
5295 TEST_f_f (nearbyint, 2097152.75, 2097153.0);
5296 TEST_f_f (nearbyint, 2492472.75, 2492473.0);
5297 TEST_f_f (nearbyint, 2886220.75, 2886221.0);
5298 TEST_f_f (nearbyint, 3058792.75, 3058793.0);
5299 TEST_f_f (nearbyint, -1048576.75, -1048577.0);
5300 TEST_f_f (nearbyint, -2097152.75, -2097153.0);
5301 TEST_f_f (nearbyint, -2492472.75, -2492473.0);
5302 TEST_f_f (nearbyint, -2886220.75, -2886221.0);
5303 TEST_f_f (nearbyint, -3058792.75, -3058793.0);
5304 #ifndef TEST_FLOAT
5305 TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
5306 TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
5307 TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
5308 TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
5309 TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
5310 TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
5311 TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
5312 TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
5313 TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
5314 TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
5315 #endif
5316
5317 END (nearbyint);
5318 }
5319
5320 static void
5321 nextafter_test (void)
5322 {
5323
5324 START (nextafter);
5325
5326 TEST_ff_f (nextafter, 0, 0, 0);
5327 TEST_ff_f (nextafter, minus_zero, 0, 0);
5328 TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
5329 TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
5330
5331 TEST_ff_f (nextafter, 9, 9, 9);
5332 TEST_ff_f (nextafter, -9, -9, -9);
5333 TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
5334 TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
5335
5336 TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
5337 TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
5338 TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
5339
5340 FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
5341 LDBL_MAX, DBL_MAX, FLT_MAX);
5342 TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
5343 TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
5344
5345 #ifdef TEST_LDOUBLE
5346 // XXX Enable once gcc is fixed.
5347 //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
5348 #endif
5349
5350 /* XXX We need the hexadecimal FP number representation here for further
5351 tests. */
5352
5353 END (nextafter);
5354 }
5355
5356
5357 static void
5358 nexttoward_test (void)
5359 {
5360 START (nexttoward);
5361 TEST_ff_f (nexttoward, 0, 0, 0);
5362 TEST_ff_f (nexttoward, minus_zero, 0, 0);
5363 TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
5364 TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
5365
5366 TEST_ff_f (nexttoward, 9, 9, 9);
5367 TEST_ff_f (nexttoward, -9, -9, -9);
5368 TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
5369 TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
5370
5371 TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
5372 TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
5373 TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
5374
5375 /* XXX We need the hexadecimal FP number representation here for further
5376 tests. */
5377
5378 END (nexttoward);
5379 }
5380
5381
5382 static void
5383 pow_test (void)
5384 {
5385
5386 errno = 0;
5387 FUNC(pow) (0, 0);
5388 if (errno == ENOSYS)
5389 /* Function not implemented. */
5390 return;
5391
5392 START (pow);
5393
5394 TEST_ff_f (pow, 0, 0, 1);
5395 TEST_ff_f (pow, 0, minus_zero, 1);
5396 TEST_ff_f (pow, minus_zero, 0, 1);
5397 TEST_ff_f (pow, minus_zero, minus_zero, 1);
5398
5399 TEST_ff_f (pow, 10, 0, 1);
5400 TEST_ff_f (pow, 10, minus_zero, 1);
5401 TEST_ff_f (pow, -10, 0, 1);
5402 TEST_ff_f (pow, -10, minus_zero, 1);
5403
5404 TEST_ff_f (pow, nan_value, 0, 1);
5405 TEST_ff_f (pow, nan_value, minus_zero, 1);
5406
5407
5408 #ifndef TEST_INLINE
5409 TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
5410 TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
5411 TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
5412 TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
5413
5414 TEST_ff_f (pow, 0.9L, plus_infty, 0);
5415 TEST_ff_f (pow, 1e-7L, plus_infty, 0);
5416 TEST_ff_f (pow, -0.9L, plus_infty, 0);
5417 TEST_ff_f (pow, -1e-7L, plus_infty, 0);
5418
5419 TEST_ff_f (pow, 1.1L, minus_infty, 0);
5420 TEST_ff_f (pow, plus_infty, minus_infty, 0);
5421 TEST_ff_f (pow, -1.1L, minus_infty, 0);
5422 TEST_ff_f (pow, minus_infty, minus_infty, 0);
5423
5424 TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
5425 TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
5426 TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
5427 TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
5428
5429 TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
5430 TEST_ff_f (pow, plus_infty, 1, plus_infty);
5431 TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
5432
5433 TEST_ff_f (pow, plus_infty, -1e-7L, 0);
5434 TEST_ff_f (pow, plus_infty, -1, 0);
5435 TEST_ff_f (pow, plus_infty, -1e7L, 0);
5436
5437 TEST_ff_f (pow, minus_infty, 1, minus_infty);
5438 TEST_ff_f (pow, minus_infty, 11, minus_infty);
5439 TEST_ff_f (pow, minus_infty, 1001, minus_infty);
5440
5441 TEST_ff_f (pow, minus_infty, 2, plus_infty);
5442 TEST_ff_f (pow, minus_infty, 12, plus_infty);
5443 TEST_ff_f (pow, minus_infty, 1002, plus_infty);
5444 TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
5445 TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
5446 TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
5447 TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
5448
5449 TEST_ff_f (pow, minus_infty, -1, minus_zero);
5450 TEST_ff_f (pow, minus_infty, -11, minus_zero);
5451 TEST_ff_f (pow, minus_infty, -1001, minus_zero);
5452
5453 TEST_ff_f (pow, minus_infty, -2, 0);
5454 TEST_ff_f (pow, minus_infty, -12, 0);
5455 TEST_ff_f (pow, minus_infty, -1002, 0);
5456 TEST_ff_f (pow, minus_infty, -0.1L, 0);
5457 TEST_ff_f (pow, minus_infty, -1.1L, 0);
5458 TEST_ff_f (pow, minus_infty, -11.1L, 0);
5459 TEST_ff_f (pow, minus_infty, -1001.1L, 0);
5460 #endif
5461
5462 TEST_ff_f (pow, nan_value, nan_value, nan_value);
5463 TEST_ff_f (pow, 0, nan_value, nan_value);
5464 TEST_ff_f (pow, 1, nan_value, 1);
5465 TEST_ff_f (pow, -1, nan_value, nan_value);
5466 TEST_ff_f (pow, nan_value, 1, nan_value);
5467 TEST_ff_f (pow, nan_value, -1, nan_value);
5468
5469 /* pow (x, NaN) == NaN. */
5470 TEST_ff_f (pow, 3.0, nan_value, nan_value);
5471 TEST_ff_f (pow, minus_zero, nan_value, nan_value);
5472 TEST_ff_f (pow, plus_infty, nan_value, nan_value);
5473 TEST_ff_f (pow, -3.0, nan_value, nan_value);
5474 TEST_ff_f (pow, minus_infty, nan_value, nan_value);
5475
5476 TEST_ff_f (pow, nan_value, 3.0, nan_value);
5477 TEST_ff_f (pow, nan_value, -3.0, nan_value);
5478 TEST_ff_f (pow, nan_value, plus_infty, nan_value);
5479 TEST_ff_f (pow, nan_value, minus_infty, nan_value);
5480 TEST_ff_f (pow, nan_value, 2.5, nan_value);
5481 TEST_ff_f (pow, nan_value, -2.5, nan_value);
5482
5483 TEST_ff_f (pow, 1, plus_infty, 1);
5484 TEST_ff_f (pow, -1, plus_infty, 1);
5485 TEST_ff_f (pow, 1, minus_infty, 1);
5486 TEST_ff_f (pow, -1, minus_infty, 1);
5487 TEST_ff_f (pow, 1, 1, 1);
5488 TEST_ff_f (pow, 1, -1, 1);
5489 TEST_ff_f (pow, 1, 1.25, 1);
5490 TEST_ff_f (pow, 1, -1.25, 1);
5491 TEST_ff_f (pow, 1, 0x1p62L, 1);
5492 TEST_ff_f (pow, 1, 0x1p63L, 1);
5493 TEST_ff_f (pow, 1, 0x1p64L, 1);
5494 TEST_ff_f (pow, 1, 0x1p72L, 1);
5495
5496 /* pow (x, +-0) == 1. */
5497 TEST_ff_f (pow, plus_infty, 0, 1);
5498 TEST_ff_f (pow, plus_infty, minus_zero, 1);
5499 TEST_ff_f (pow, minus_infty, 0, 1);
5500 TEST_ff_f (pow, minus_infty, minus_zero, 1);
5501 TEST_ff_f (pow, 32.75L, 0, 1);
5502 TEST_ff_f (pow, 32.75L, minus_zero, 1);
5503 TEST_ff_f (pow, -32.75L, 0, 1);
5504 TEST_ff_f (pow, -32.75L, minus_zero, 1);
5505 TEST_ff_f (pow, 0x1p72L, 0, 1);
5506 TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
5507 TEST_ff_f (pow, 0x1p-72L, 0, 1);
5508 TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
5509
5510 TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
5511 TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
5512 TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
5513 TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
5514
5515 errno = 0;
5516 TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5517 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5518 errno = 0;
5519 TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5520 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5521 errno = 0;
5522 TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5523 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5524 #ifndef TEST_FLOAT
5525 errno = 0;
5526 TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5527 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5528 #endif
5529 #ifdef TEST_LDOUBLE
5530 # if LDBL_MANT_DIG >= 64
5531 errno = 0;
5532 TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5533 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5534 # endif
5535 # if LDBL_MANT_DIG >= 106
5536 errno = 0;
5537 TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5538 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5539 # endif
5540 # if LDBL_MANT_DIG >= 113
5541 errno = 0;
5542 TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5543 check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5544 # endif
5545 #endif
5546 TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5547 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5548 errno = 0;
5549 TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5550 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5551 errno = 0;
5552 TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5553 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5554 errno = 0;
5555 TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5556 check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5557 #ifndef TEST_FLOAT
5558 errno = 0;
5559 TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5560 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5561 errno = 0;
5562 TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5563 check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5564 #endif
5565 #ifdef TEST_LDOUBLE
5566 # if LDBL_MANT_DIG >= 64
5567 errno = 0;
5568 TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5569 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5570 errno = 0;
5571 TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5572 check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5573 # endif
5574 # if LDBL_MANT_DIG >= 106
5575 errno = 0;
5576 TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5577 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5578 errno = 0;
5579 TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5580 check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5581 # endif
5582 # if LDBL_MANT_DIG >= 113
5583 errno = 0;
5584 TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5585 check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5586 errno = 0;
5587 TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5588 check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5589 # endif
5590 #endif
5591
5592 errno = 0;
5593 TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5594 check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5595 errno = 0;
5596 TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5597 check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5598 errno = 0;
5599 TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5600 check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5601 errno = 0;
5602 TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5603 check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5604 errno = 0;
5605 TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5606 check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5607 errno = 0;
5608 TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5609 check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5610 errno = 0;
5611 TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5612 check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5613 errno = 0;
5614 TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5615 check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5616 errno = 0;
5617 TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5618 check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5619 errno = 0;
5620 TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5621 check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5622
5623 TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
5624 TEST_ff_f (pow, 10, -0x1p72L, 0);
5625 /* Bug 13873: OVERFLOW exception may be missing. */
5626 TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
5627 /* Bug 13872: spurious OVERFLOW exception may be present. */
5628 TEST_ff_f (pow, 10, -max_value, 0, OVERFLOW_EXCEPTION_OK);
5629
5630 TEST_ff_f (pow, 0, 1, 0);
5631 TEST_ff_f (pow, 0, 11, 0);
5632
5633 TEST_ff_f (pow, minus_zero, 1, minus_zero);
5634 TEST_ff_f (pow, minus_zero, 11, minus_zero);
5635
5636 TEST_ff_f (pow, 0, 2, 0);
5637 TEST_ff_f (pow, 0, 11.1L, 0);
5638
5639 TEST_ff_f (pow, minus_zero, 2, 0);
5640 TEST_ff_f (pow, minus_zero, 11.1L, 0);
5641 TEST_ff_f (pow, 0, plus_infty, 0);
5642 TEST_ff_f (pow, minus_zero, plus_infty, 0);
5643
5644 #ifndef TEST_INLINE
5645 /* pow (x, +inf) == +inf for |x| > 1. */
5646 TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
5647
5648 /* pow (x, +inf) == +0 for |x| < 1. */
5649 TEST_ff_f (pow, 0.5, plus_infty, 0.0);
5650
5651 /* pow (x, -inf) == +0 for |x| > 1. */
5652 TEST_ff_f (pow, 1.5, minus_infty, 0.0);
5653
5654 /* pow (x, -inf) == +inf for |x| < 1. */
5655 TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
5656 #endif
5657
5658 /* pow (+inf, y) == +inf for y > 0. */
5659 TEST_ff_f (pow, plus_infty, 2, plus_infty);
5660 TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
5661 #ifndef TEST_FLOAT
5662 TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
5663 #endif
5664 #ifdef TEST_LDOUBLE
5665 # if LDBL_MANT_DIG >= 64
5666 TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
5667 # endif
5668 # if LDBL_MANT_DIG >= 106
5669 TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
5670 # endif
5671 # if LDBL_MANT_DIG >= 113
5672 TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
5673 # endif
5674 #endif
5675 TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
5676 TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
5677 TEST_ff_f (pow, plus_infty, max_value, plus_infty);
5678
5679 /* pow (+inf, y) == +0 for y < 0. */
5680 TEST_ff_f (pow, plus_infty, -1, 0.0);
5681 TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
5682 #ifndef TEST_FLOAT
5683 TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
5684 #endif
5685 #ifdef TEST_LDOUBLE
5686 # if LDBL_MANT_DIG >= 64
5687 TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
5688 # endif
5689 # if LDBL_MANT_DIG >= 106
5690 TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
5691 # endif
5692 # if LDBL_MANT_DIG >= 113
5693 TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
5694 # endif
5695 #endif
5696 TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
5697 TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
5698 TEST_ff_f (pow, plus_infty, -max_value, 0.0);
5699
5700 /* pow (-inf, y) == -inf for y an odd integer > 0. */
5701 TEST_ff_f (pow, minus_infty, 27, minus_infty);
5702 TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
5703 TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
5704 #ifndef TEST_FLOAT
5705 TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
5706 TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
5707 #endif
5708 #ifdef TEST_LDOUBLE
5709 # if LDBL_MANT_DIG >= 64
5710 TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
5711 TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
5712 # endif
5713 # if LDBL_MANT_DIG >= 106
5714 TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
5715 TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
5716 # endif
5717 # if LDBL_MANT_DIG >= 113
5718 TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
5719 TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
5720 # endif
5721 #endif
5722
5723 /* pow (-inf, y) == +inf for y > 0 and not an odd integer. */
5724 TEST_ff_f (pow, minus_infty, 28, plus_infty);
5725 TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
5726 TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
5727 TEST_ff_f (pow, minus_infty, max_value, plus_infty);
5728
5729 /* pow (-inf, y) == -0 for y an odd integer < 0. */
5730 TEST_ff_f (pow, minus_infty, -3, minus_zero);
5731 TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
5732 TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
5733 #ifndef TEST_FLOAT
5734 TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
5735 TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
5736 #endif
5737 #ifdef TEST_LDOUBLE
5738 # if LDBL_MANT_DIG >= 64
5739 TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
5740 TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
5741 # endif
5742 # if LDBL_MANT_DIG >= 106
5743 TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5744 TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5745 # endif
5746 # if LDBL_MANT_DIG >= 113
5747 TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5748 TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5749 # endif
5750 #endif
5751 /* pow (-inf, y) == +0 for y < 0 and not an odd integer. */
5752 TEST_ff_f (pow, minus_infty, -2.0, 0.0);
5753 TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
5754 TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
5755 TEST_ff_f (pow, minus_infty, -max_value, 0.0);
5756
5757 /* pow (+0, y) == +0 for y an odd integer > 0. */
5758 TEST_ff_f (pow, 0.0, 27, 0.0);
5759 TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
5760 #ifndef TEST_FLOAT
5761 TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
5762 #endif
5763 #ifdef TEST_LDOUBLE
5764 # if LDBL_MANT_DIG >= 64
5765 TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
5766 # endif
5767 # if LDBL_MANT_DIG >= 106
5768 TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
5769 # endif
5770 # if LDBL_MANT_DIG >= 113
5771 TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
5772 # endif
5773 #endif
5774
5775 /* pow (-0, y) == -0 for y an odd integer > 0. */
5776 TEST_ff_f (pow, minus_zero, 27, minus_zero);
5777 TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
5778 TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
5779 #ifndef TEST_FLOAT
5780 TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
5781 TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
5782 #endif
5783 #ifdef TEST_LDOUBLE
5784 # if LDBL_MANT_DIG >= 64
5785 TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
5786 TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
5787 # endif
5788 # if LDBL_MANT_DIG >= 106
5789 TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5790 TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5791 # endif
5792 # if LDBL_MANT_DIG >= 113
5793 TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5794 TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5795 # endif
5796 #endif
5797
5798 /* pow (+0, y) == +0 for y > 0 and not an odd integer. */
5799 TEST_ff_f (pow, 0.0, 4, 0.0);
5800 TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
5801 TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
5802 TEST_ff_f (pow, 0.0, max_value, 0.0);
5803
5804 /* pow (-0, y) == +0 for y > 0 and not an odd integer. */
5805 TEST_ff_f (pow, minus_zero, 4, 0.0);
5806 TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
5807 TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
5808 TEST_ff_f (pow, minus_zero, max_value, 0.0);
5809
5810 TEST_ff_f (pow, 16, 0.25L, 2);
5811 TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
5812 TEST_ff_f (pow, 2, 4, 16);
5813 TEST_ff_f (pow, 256, 8, 0x1p64L);
5814
5815 TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
5816
5817 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
5818 TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
5819 #endif
5820
5821 TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
5822 TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
5823 #ifndef TEST_FLOAT
5824 TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
5825 TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
5826 #endif
5827 #ifdef TEST_LDOUBLE
5828 # if LDBL_MANT_DIG >= 64
5829 TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
5830 TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
5831 # endif
5832 # if LDBL_MANT_DIG >= 106
5833 TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
5834 TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
5835 # endif
5836 # if LDBL_MANT_DIG >= 113
5837 TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
5838 TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
5839 # endif
5840 #endif
5841 TEST_ff_f (pow, -1.0, -max_value, 1.0);
5842
5843 TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
5844 TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
5845 #ifndef TEST_FLOAT
5846 TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
5847 TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
5848 #endif
5849 #ifdef TEST_LDOUBLE
5850 # if LDBL_MANT_DIG >= 64
5851 TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
5852 TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
5853 # endif
5854 # if LDBL_MANT_DIG >= 106
5855 TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
5856 TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
5857 # endif
5858 # if LDBL_MANT_DIG >= 113
5859 TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
5860 TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
5861 # endif
5862 #endif
5863 TEST_ff_f (pow, -1.0, max_value, 1.0);
5864
5865 TEST_ff_f (pow, -2.0, 126, 0x1p126);
5866 TEST_ff_f (pow, -2.0, 127, -0x1p127);
5867 TEST_ff_f (pow, -2.0, -126, 0x1p-126);
5868 TEST_ff_f (pow, -2.0, -127, -0x1p-127);
5869
5870 TEST_ff_f (pow, -2.0, -0xffffff, minus_zero);
5871 TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero);
5872 #ifndef TEST_FLOAT
5873 TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero);
5874 TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero);
5875 #endif
5876 #ifdef TEST_LDOUBLE
5877 # if LDBL_MANT_DIG >= 64
5878 TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero);
5879 TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero);
5880 # endif
5881 # if LDBL_MANT_DIG >= 106
5882 TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5883 TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5884 # endif
5885 # if LDBL_MANT_DIG >= 113
5886 TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5887 TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5888 # endif
5889 #endif
5890 TEST_ff_f (pow, -2.0, -max_value, plus_zero);
5891
5892 TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
5893 TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
5894 #ifndef TEST_FLOAT
5895 TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
5896 TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
5897 #endif
5898 #ifdef TEST_LDOUBLE
5899 # if LDBL_MANT_DIG >= 64
5900 TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
5901 TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
5902 # endif
5903 # if LDBL_MANT_DIG >= 106
5904 TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
5905 TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
5906 # endif
5907 # if LDBL_MANT_DIG >= 113
5908 TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
5909 TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
5910 # endif
5911 #endif
5912 /* Bug 13873: OVERFLOW exception may be missing. */
5913 TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
5914
5915 TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
5916 TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
5917 TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
5918 TEST_ff_f (pow, -max_value, -2, plus_zero);
5919 TEST_ff_f (pow, -max_value, -3, minus_zero);
5920 TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
5921 TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
5922
5923 TEST_ff_f (pow, -max_value, -0xffffff, minus_zero);
5924 TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero);
5925 #ifndef TEST_FLOAT
5926 TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero);
5927 TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero);
5928 #endif
5929 #ifdef TEST_LDOUBLE
5930 # if LDBL_MANT_DIG >= 64
5931 TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero);
5932 TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero);
5933 # endif
5934 # if LDBL_MANT_DIG >= 106
5935 TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5936 TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5937 # endif
5938 # if LDBL_MANT_DIG >= 113
5939 TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5940 TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5941 # endif
5942 #endif
5943 /* Bug 13872: spurious OVERFLOW exception may be present. */
5944 TEST_ff_f (pow, -max_value, -max_value, plus_zero, OVERFLOW_EXCEPTION_OK);
5945
5946 TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
5947 TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
5948 #ifndef TEST_FLOAT
5949 TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
5950 TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
5951 #endif
5952 #ifdef TEST_LDOUBLE
5953 # if LDBL_MANT_DIG >= 64
5954 TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
5955 TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
5956 # endif
5957 # if LDBL_MANT_DIG >= 106
5958 TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
5959 TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
5960 # endif
5961 # if LDBL_MANT_DIG >= 113
5962 TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
5963 TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
5964 # endif
5965 #endif
5966 /* Bug 13873: OVERFLOW exception may be missing. */
5967 TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
5968
5969 TEST_ff_f (pow, -0.5, 126, 0x1p-126);
5970 TEST_ff_f (pow, -0.5, 127, -0x1p-127);
5971 TEST_ff_f (pow, -0.5, -126, 0x1p126);
5972 TEST_ff_f (pow, -0.5, -127, -0x1p127);
5973
5974 TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
5975 TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
5976 #ifndef TEST_FLOAT
5977 TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
5978 TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
5979 #endif
5980 #ifdef TEST_LDOUBLE
5981 # if LDBL_MANT_DIG >= 64
5982 TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
5983 TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
5984 # endif
5985 # if LDBL_MANT_DIG >= 106
5986 TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
5987 TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
5988 # endif
5989 # if LDBL_MANT_DIG >= 113
5990 TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
5991 TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
5992 # endif
5993 #endif
5994 /* Bug 13873: OVERFLOW exception may be missing. */
5995 TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
5996
5997 TEST_ff_f (pow, -0.5, 0xffffff, minus_zero);
5998 TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero);
5999 #ifndef TEST_FLOAT
6000 TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero);
6001 TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero);
6002 #endif
6003 #ifdef TEST_LDOUBLE
6004 # if LDBL_MANT_DIG >= 64
6005 TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero);
6006 TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero);
6007 # endif
6008 # if LDBL_MANT_DIG >= 106
6009 TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6010 TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6011 # endif
6012 # if LDBL_MANT_DIG >= 113
6013 TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6014 TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6015 # endif
6016 #endif
6017 TEST_ff_f (pow, -0.5, max_value, plus_zero);
6018
6019 TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
6020 TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
6021 TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
6022 TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
6023 TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
6024 TEST_ff_f (pow, -min_value, 1, -min_value);
6025 TEST_ff_f (pow, -min_value, 2, plus_zero);
6026 TEST_ff_f (pow, -min_value, 3, minus_zero);
6027
6028 TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6029 TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6030 #ifndef TEST_FLOAT
6031 TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6032 TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6033 #endif
6034 #ifdef TEST_LDOUBLE
6035 # if LDBL_MANT_DIG >= 64
6036 TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6037 TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6038 # endif
6039 # if LDBL_MANT_DIG >= 106
6040 TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6041 TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6042 # endif
6043 # if LDBL_MANT_DIG >= 113
6044 TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6045 TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6046 # endif
6047 #endif
6048 /* Bug 13873: OVERFLOW exception may be missing. */
6049 TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
6050
6051 TEST_ff_f (pow, -min_value, 0xffffff, minus_zero);
6052 TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero);
6053 #ifndef TEST_FLOAT
6054 TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero);
6055 TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero);
6056 #endif
6057 #ifdef TEST_LDOUBLE
6058 # if LDBL_MANT_DIG >= 64
6059 TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero);
6060 TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero);
6061 # endif
6062 # if LDBL_MANT_DIG >= 106
6063 TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6064 TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6065 # endif
6066 # if LDBL_MANT_DIG >= 113
6067 TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6068 TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6069 # endif
6070 #endif
6071 /* Bug 13872: spurious OVERFLOW exception may be present. */
6072 TEST_ff_f (pow, -min_value, max_value, plus_zero, OVERFLOW_EXCEPTION_OK);
6073
6074 END (pow);
6075 }
6076
6077
6078 static void
6079 pow_test_tonearest (void)
6080 {
6081 int save_round_mode;
6082 errno = 0;
6083 FUNC(pow) (0, 0);
6084 if (errno == ENOSYS)
6085 /* Function not implemented. */
6086 return;
6087
6088 START (pow_tonearest);
6089
6090 save_round_mode = fegetround ();
6091
6092 if (!fesetround (FE_TONEAREST))
6093 {
6094 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6095 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6096 }
6097
6098 fesetround (save_round_mode);
6099
6100 END (pow_tonearest);
6101 }
6102
6103
6104 static void
6105 pow_test_towardzero (void)
6106 {
6107 int save_round_mode;
6108 errno = 0;
6109 FUNC(pow) (0, 0);
6110 if (errno == ENOSYS)
6111 /* Function not implemented. */
6112 return;
6113
6114 START (pow_towardzero);
6115
6116 save_round_mode = fegetround ();
6117
6118 if (!fesetround (FE_TOWARDZERO))
6119 {
6120 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6121 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6122 }
6123
6124 fesetround (save_round_mode);
6125
6126 END (pow_towardzero);
6127 }
6128
6129
6130 static void
6131 pow_test_downward (void)
6132 {
6133 int save_round_mode;
6134 errno = 0;
6135 FUNC(pow) (0, 0);
6136 if (errno == ENOSYS)
6137 /* Function not implemented. */
6138 return;
6139
6140 START (pow_downward);
6141
6142 save_round_mode = fegetround ();
6143
6144 if (!fesetround (FE_DOWNWARD))
6145 {
6146 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6147 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6148 }
6149
6150 fesetround (save_round_mode);
6151
6152 END (pow_downward);
6153 }
6154
6155
6156 static void
6157 pow_test_upward (void)
6158 {
6159 int save_round_mode;
6160 errno = 0;
6161 FUNC(pow) (0, 0);
6162 if (errno == ENOSYS)
6163 /* Function not implemented. */
6164 return;
6165
6166 START (pow_upward);
6167
6168 save_round_mode = fegetround ();
6169
6170 if (!fesetround (FE_UPWARD))
6171 {
6172 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6173 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6174 }
6175
6176 fesetround (save_round_mode);
6177
6178 END (pow_upward);
6179 }
6180
6181
6182 static void
6183 remainder_test (void)
6184 {
6185 errno = 0;
6186 FUNC(remainder) (1.625, 1.0);
6187 if (errno == ENOSYS)
6188 /* Function not implemented. */
6189 return;
6190
6191 START (remainder);
6192
6193 errno = 0;
6194 TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
6195 check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
6196 errno = 0;
6197 TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
6198 check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
6199 errno = 0;
6200 TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
6201 check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
6202 errno = 0;
6203 TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
6204 check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
6205 errno = 0;
6206 TEST_ff_f (remainder, nan_value, nan_value, nan_value);
6207 check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
6208 errno = 0;
6209 TEST_ff_f (remainder, 0, nan_value, nan_value);
6210 check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
6211 errno = 0;
6212 TEST_ff_f (remainder, nan_value, 0, nan_value);
6213 check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
6214
6215 TEST_ff_f (remainder, 1.625, 1.0, -0.375);
6216 TEST_ff_f (remainder, -1.625, 1.0, 0.375);
6217 TEST_ff_f (remainder, 1.625, -1.0, -0.375);
6218 TEST_ff_f (remainder, -1.625, -1.0, 0.375);
6219 TEST_ff_f (remainder, 5.0, 2.0, 1.0);
6220 TEST_ff_f (remainder, 3.0, 2.0, -1.0);
6221
6222 END (remainder);
6223 }
6224
6225 static void
6226 remquo_test (void)
6227 {
6228 /* x is needed. */
6229 int x;
6230
6231 errno = 0;
6232 FUNC(remquo) (1.625, 1.0, &x);
6233 if (errno == ENOSYS)
6234 /* Function not implemented. */
6235 return;
6236
6237 START (remquo);
6238
6239 TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
6240 TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
6241 TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
6242 TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
6243 TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
6244
6245 TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
6246 TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
6247 TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
6248 TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
6249
6250 TEST_ffI_f1 (remquo, 5, 2, 1, 2);
6251 TEST_ffI_f1 (remquo, 3, 2, -1, 2);
6252
6253 END (remquo);
6254 }
6255
6256 static void
6257 rint_test (void)
6258 {
6259 START (rint);
6260
6261 TEST_f_f (rint, 0.0, 0.0);
6262 TEST_f_f (rint, minus_zero, minus_zero);
6263 TEST_f_f (rint, plus_infty, plus_infty);
6264 TEST_f_f (rint, minus_infty, minus_infty);
6265
6266 /* Default rounding mode is round to even. */
6267 TEST_f_f (rint, 0.5, 0.0);
6268 TEST_f_f (rint, 1.5, 2.0);
6269 TEST_f_f (rint, 2.5, 2.0);
6270 TEST_f_f (rint, 3.5, 4.0);
6271 TEST_f_f (rint, 4.5, 4.0);
6272 TEST_f_f (rint, -0.5, -0.0);
6273 TEST_f_f (rint, -1.5, -2.0);
6274 TEST_f_f (rint, -2.5, -2.0);
6275 TEST_f_f (rint, -3.5, -4.0);
6276 TEST_f_f (rint, -4.5, -4.0);
6277 TEST_f_f (rint, 0.1, 0.0);
6278 TEST_f_f (rint, 0.25, 0.0);
6279 TEST_f_f (rint, 0.625, 1.0);
6280 TEST_f_f (rint, -0.1, -0.0);
6281 TEST_f_f (rint, -0.25, -0.0);
6282 TEST_f_f (rint, -0.625, -1.0);
6283 TEST_f_f (rint, 262144.75, 262145.0);
6284 TEST_f_f (rint, 262142.75, 262143.0);
6285 TEST_f_f (rint, 524286.75, 524287.0);
6286 TEST_f_f (rint, 524288.75, 524289.0);
6287 TEST_f_f (rint, 1048576.75, 1048577.0);
6288 TEST_f_f (rint, 2097152.75, 2097153.0);
6289 TEST_f_f (rint, -1048576.75, -1048577.0);
6290 TEST_f_f (rint, -2097152.75, -2097153.0);
6291 #ifndef TEST_FLOAT
6292 TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6293 TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6294 TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6295 TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6296 TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6297 TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6298 TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6299 TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6300 TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6301 TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6302 #endif
6303 #ifdef TEST_LDOUBLE
6304 /* The result can only be represented in long double. */
6305 TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6306 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6307 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6308 TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6309 TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6310
6311 # if LDBL_MANT_DIG > 100
6312 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6313 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6314 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6315 # endif
6316
6317 TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6318 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6319 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6320 TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6321 TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6322
6323 # if LDBL_MANT_DIG > 100
6324 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6325 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6326 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6327
6328 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6329 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6330 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6331 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6332 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6333 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6334
6335 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6336 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6337 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6338 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6339 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6340 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6341 # endif
6342
6343 TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
6344 TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
6345 TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
6346 TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
6347 TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
6348
6349 TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
6350 TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
6351 TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
6352 TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
6353 TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
6354
6355 TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
6356 TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
6357 TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
6358 TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
6359 TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
6360
6361 TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
6362 TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
6363 TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
6364 TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
6365 TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
6366
6367 TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6368 TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6369 TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
6370 TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6371 TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6372 #endif
6373
6374 END (rint);
6375 }
6376
6377 static void
6378 rint_test_tonearest (void)
6379 {
6380 int save_round_mode;
6381 START (rint_tonearest);
6382
6383 save_round_mode = fegetround ();
6384
6385 if (!fesetround (FE_TONEAREST))
6386 {
6387 TEST_f_f (rint, 2.0, 2.0);
6388 TEST_f_f (rint, 1.5, 2.0);
6389 TEST_f_f (rint, 1.0, 1.0);
6390 TEST_f_f (rint, 0.5, 0.0);
6391 TEST_f_f (rint, 0.0, 0.0);
6392 TEST_f_f (rint, minus_zero, minus_zero);
6393 TEST_f_f (rint, -0.5, -0.0);
6394 TEST_f_f (rint, -1.0, -1.0);
6395 TEST_f_f (rint, -1.5, -2.0);
6396 TEST_f_f (rint, -2.0, -2.0);
6397 TEST_f_f (rint, 0.1, 0.0);
6398 TEST_f_f (rint, 0.25, 0.0);
6399 TEST_f_f (rint, 0.625, 1.0);
6400 TEST_f_f (rint, -0.1, -0.0);
6401 TEST_f_f (rint, -0.25, -0.0);
6402 TEST_f_f (rint, -0.625, -1.0);
6403 TEST_f_f (rint, 1048576.75, 1048577.0);
6404 TEST_f_f (rint, 2097152.75, 2097153.0);
6405 TEST_f_f (rint, -1048576.75, -1048577.0);
6406 TEST_f_f (rint, -2097152.75, -2097153.0);
6407 #ifndef TEST_FLOAT
6408 TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6409 TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6410 TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6411 TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6412 TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6413 TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6414 TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6415 TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6416 TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6417 TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6418 #endif
6419 #ifdef TEST_LDOUBLE
6420 /* The result can only be represented in long double. */
6421 TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6422 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6423 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6424 TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6425 TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6426 # if LDBL_MANT_DIG > 100
6427 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6428 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6429 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6430 # endif
6431 TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6432 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6433 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6434 TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6435 TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6436 # if LDBL_MANT_DIG > 100
6437 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6438 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6439 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6440
6441 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6442 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6443 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6444 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6445 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6446 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6447
6448 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6449 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6450 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6451 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6452 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6453 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6454 # endif
6455 #endif
6456 }
6457
6458 fesetround (save_round_mode);
6459
6460 END (rint_tonearest);
6461 }
6462
6463 static void
6464 rint_test_towardzero (void)
6465 {
6466 int save_round_mode;
6467 START (rint_towardzero);
6468
6469 save_round_mode = fegetround ();
6470
6471 if (!fesetround (FE_TOWARDZERO))
6472 {
6473 TEST_f_f (rint, 2.0, 2.0);
6474 TEST_f_f (rint, 1.5, 1.0);
6475 TEST_f_f (rint, 1.0, 1.0);
6476 TEST_f_f (rint, 0.5, 0.0);
6477 TEST_f_f (rint, 0.0, 0.0);
6478 TEST_f_f (rint, minus_zero, minus_zero);
6479 TEST_f_f (rint, -0.5, -0.0);
6480 TEST_f_f (rint, -1.0, -1.0);
6481 TEST_f_f (rint, -1.5, -1.0);
6482 TEST_f_f (rint, -2.0, -2.0);
6483 TEST_f_f (rint, 0.1, 0.0);
6484 TEST_f_f (rint, 0.25, 0.0);
6485 TEST_f_f (rint, 0.625, 0.0);
6486 TEST_f_f (rint, -0.1, -0.0);
6487 TEST_f_f (rint, -0.25, -0.0);
6488 TEST_f_f (rint, -0.625, -0.0);
6489 TEST_f_f (rint, 1048576.75, 1048576.0);
6490 TEST_f_f (rint, 2097152.75, 2097152.0);
6491 TEST_f_f (rint, -1048576.75, -1048576.0);
6492 TEST_f_f (rint, -2097152.75, -2097152.0);
6493 #ifndef TEST_FLOAT
6494 TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6495 TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6496 TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6497 TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6498 TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6499 TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6500 TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6501 TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6502 TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6503 TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6504 #endif
6505 #ifdef TEST_LDOUBLE
6506 /* The result can only be represented in long double. */
6507 TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6508 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6509 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6510 TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6511 TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6512 # if LDBL_MANT_DIG > 100
6513 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6514 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6515 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6516 # endif
6517 TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6518 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6519 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6520 TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6521 TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6522 # if LDBL_MANT_DIG > 100
6523 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6524 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6525 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6526
6527 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6528 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6529 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6530 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6531 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6532 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6533
6534 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6535 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6536 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6537 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
6538 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6539 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6540 # endif
6541 #endif
6542 }
6543
6544 fesetround (save_round_mode);
6545
6546 END (rint_towardzero);
6547 }
6548
6549 static void
6550 rint_test_downward (void)
6551 {
6552 int save_round_mode;
6553 START (rint_downward);
6554
6555 save_round_mode = fegetround ();
6556
6557 if (!fesetround (FE_DOWNWARD))
6558 {
6559 TEST_f_f (rint, 2.0, 2.0);
6560 TEST_f_f (rint, 1.5, 1.0);
6561 TEST_f_f (rint, 1.0, 1.0);
6562 TEST_f_f (rint, 0.5, 0.0);
6563 TEST_f_f (rint, 0.0, 0.0);
6564 TEST_f_f (rint, minus_zero, minus_zero);
6565 TEST_f_f (rint, -0.5, -1.0);
6566 TEST_f_f (rint, -1.0, -1.0);
6567 TEST_f_f (rint, -1.5, -2.0);
6568 TEST_f_f (rint, -2.0, -2.0);
6569 TEST_f_f (rint, 0.1, 0.0);
6570 TEST_f_f (rint, 0.25, 0.0);
6571 TEST_f_f (rint, 0.625, 0.0);
6572 TEST_f_f (rint, -0.1, -1.0);
6573 TEST_f_f (rint, -0.25, -1.0);
6574 TEST_f_f (rint, -0.625, -1.0);
6575 TEST_f_f (rint, 1048576.75, 1048576.0);
6576 TEST_f_f (rint, 2097152.75, 2097152.0);
6577 TEST_f_f (rint, -1048576.75, -1048577.0);
6578 TEST_f_f (rint, -2097152.75, -2097153.0);
6579 #ifndef TEST_FLOAT
6580 TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6581 TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6582 TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6583 TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6584 TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6585 TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6586 TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6587 TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6588 TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6589 TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6590 #endif
6591 #ifdef TEST_LDOUBLE
6592 /* The result can only be represented in long double. */
6593 TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6594 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6595 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6596 TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6597 TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6598 # if LDBL_MANT_DIG > 100
6599 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6600 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6601 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6602 # endif
6603 TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6604 TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
6605 TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
6606 TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6607 TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6608 # if LDBL_MANT_DIG > 100
6609 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6610 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6611 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6612
6613 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6614 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6615 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6616 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6617 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6618 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6619
6620 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
6621 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
6622 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
6623 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6624 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6625 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6626 # endif
6627 #endif
6628 }
6629
6630 fesetround (save_round_mode);
6631
6632 END (rint_downward);
6633 }
6634
6635 static void
6636 rint_test_upward (void)
6637 {
6638 int save_round_mode;
6639 START (rint_upward);
6640
6641 save_round_mode = fegetround ();
6642
6643 if (!fesetround (FE_UPWARD))
6644 {
6645 TEST_f_f (rint, 2.0, 2.0);
6646 TEST_f_f (rint, 1.5, 2.0);
6647 TEST_f_f (rint, 1.0, 1.0);
6648 TEST_f_f (rint, 0.5, 1.0);
6649 TEST_f_f (rint, 0.0, 0.0);
6650 TEST_f_f (rint, minus_zero, minus_zero);
6651 TEST_f_f (rint, -0.5, -0.0);
6652 TEST_f_f (rint, -1.0, -1.0);
6653 TEST_f_f (rint, -1.5, -1.0);
6654 TEST_f_f (rint, -2.0, -2.0);
6655 TEST_f_f (rint, 0.1, 1.0);
6656 TEST_f_f (rint, 0.25, 1.0);
6657 TEST_f_f (rint, 0.625, 1.0);
6658 TEST_f_f (rint, -0.1, -0.0);
6659 TEST_f_f (rint, -0.25, -0.0);
6660 TEST_f_f (rint, -0.625, -0.0);
6661 TEST_f_f (rint, 1048576.75, 1048577.0);
6662 TEST_f_f (rint, 2097152.75, 2097153.0);
6663 TEST_f_f (rint, -1048576.75, -1048576.0);
6664 TEST_f_f (rint, -2097152.75, -2097152.0);
6665 #ifndef TEST_FLOAT
6666 TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6667 TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6668 TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6669 TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6670 TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6671 TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6672 TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6673 TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6674 TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6675 TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6676 #endif
6677 #ifdef TEST_LDOUBLE
6678 /* The result can only be represented in long double. */
6679 TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6680 TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
6681 TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
6682 TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6683 TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6684 # if LDBL_MANT_DIG > 100
6685 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6686 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6687 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6688 # endif
6689 TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6690 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6691 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6692 TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6693 TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6694 # if LDBL_MANT_DIG > 100
6695 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6696 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6697 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6698
6699 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
6700 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
6701 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
6702 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6703 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6704 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6705
6706 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6707 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6708 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6709 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
6710 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6711 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6712 # endif
6713 #endif
6714 }
6715
6716 fesetround (save_round_mode);
6717
6718 END (rint_upward);
6719 }
6720
6721 static void
6722 round_test (void)
6723 {
6724 START (round);
6725
6726 TEST_f_f (round, 0, 0);
6727 TEST_f_f (round, minus_zero, minus_zero);
6728 TEST_f_f (round, 0.2L, 0.0);
6729 TEST_f_f (round, -0.2L, minus_zero);
6730 TEST_f_f (round, 0.5, 1.0);
6731 TEST_f_f (round, -0.5, -1.0);
6732 TEST_f_f (round, 0.8L, 1.0);
6733 TEST_f_f (round, -0.8L, -1.0);
6734 TEST_f_f (round, 1.5, 2.0);
6735 TEST_f_f (round, -1.5, -2.0);
6736 TEST_f_f (round, 0.1, 0.0);
6737 TEST_f_f (round, 0.25, 0.0);
6738 TEST_f_f (round, 0.625, 1.0);
6739 TEST_f_f (round, -0.1, -0.0);
6740 TEST_f_f (round, -0.25, -0.0);
6741 TEST_f_f (round, -0.625, -1.0);
6742 TEST_f_f (round, 2097152.5, 2097153);
6743 TEST_f_f (round, -2097152.5, -2097153);
6744
6745 #ifdef TEST_LDOUBLE
6746 /* The result can only be represented in long double. */
6747 TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
6748 TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
6749 TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
6750 TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
6751 TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
6752 # if LDBL_MANT_DIG > 100
6753 TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
6754 TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
6755 TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
6756 # endif
6757
6758 TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
6759 TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
6760 TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
6761 TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
6762 TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
6763 # if LDBL_MANT_DIG > 100
6764 TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
6765 TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
6766 TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
6767 # endif
6768
6769 TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
6770 TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
6771 TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
6772 TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
6773 TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
6774
6775 TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
6776 TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
6777 TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
6778 TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
6779 TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
6780
6781 # if LDBL_MANT_DIG > 100
6782 TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
6783 TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
6784 TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
6785 TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
6786 TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
6787 TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
6788
6789 TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
6790 TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
6791 TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
6792 TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
6793 TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
6794 TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
6795 # endif
6796
6797 TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
6798 TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
6799 TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
6800 TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
6801 TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
6802
6803 TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
6804 TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
6805 TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
6806 TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
6807 TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
6808
6809 TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6810 TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6811 TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
6812 TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6813 TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6814 #endif
6815
6816 END (round);
6817 }
6818
6819
6820 static void
6821 scalb_test (void)
6822 {
6823
6824 START (scalb);
6825
6826 TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
6827 TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
6828
6829 TEST_ff_f (scalb, 0, nan_value, nan_value);
6830 TEST_ff_f (scalb, 1, nan_value, nan_value);
6831
6832 TEST_ff_f (scalb, 1, 0, 1);
6833 TEST_ff_f (scalb, -1, 0, -1);
6834
6835 TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
6836 TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
6837
6838 TEST_ff_f (scalb, 0, 2, 0);
6839 TEST_ff_f (scalb, minus_zero, -4, minus_zero);
6840 TEST_ff_f (scalb, 0, 0, 0);
6841 TEST_ff_f (scalb, minus_zero, 0, minus_zero);
6842 TEST_ff_f (scalb, 0, -1, 0);
6843 TEST_ff_f (scalb, minus_zero, -10, minus_zero);
6844 TEST_ff_f (scalb, 0, minus_infty, 0);
6845 TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
6846
6847 TEST_ff_f (scalb, plus_infty, -1, plus_infty);
6848 TEST_ff_f (scalb, minus_infty, -10, minus_infty);
6849 TEST_ff_f (scalb, plus_infty, 0, plus_infty);
6850 TEST_ff_f (scalb, minus_infty, 0, minus_infty);
6851 TEST_ff_f (scalb, plus_infty, 2, plus_infty);
6852 TEST_ff_f (scalb, minus_infty, 100, minus_infty);
6853
6854 TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
6855 TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
6856
6857 TEST_ff_f (scalb, 1, plus_infty, plus_infty);
6858 TEST_ff_f (scalb, -1, plus_infty, minus_infty);
6859 TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
6860 TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
6861
6862 TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6863 TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6864
6865 TEST_ff_f (scalb, nan_value, 1, nan_value);
6866 TEST_ff_f (scalb, 1, nan_value, nan_value);
6867 TEST_ff_f (scalb, nan_value, 0, nan_value);
6868 TEST_ff_f (scalb, 0, nan_value, nan_value);
6869 TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
6870 TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
6871 TEST_ff_f (scalb, nan_value, nan_value, nan_value);
6872
6873 TEST_ff_f (scalb, 0.8L, 4, 12.8L);
6874 TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
6875
6876 END (scalb);
6877 }
6878
6879
6880 static void
6881 scalbn_test (void)
6882 {
6883
6884 START (scalbn);
6885
6886 TEST_fi_f (scalbn, 0, 0, 0);
6887 TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
6888
6889 TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
6890 TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
6891 TEST_fi_f (scalbn, nan_value, 1, nan_value);
6892
6893 TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
6894 TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
6895
6896 TEST_fi_f (scalbn, 1, 0L, 1);
6897
6898 TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6899 TEST_fi_f (scalbn, 1, INT_MIN, plus_zero);
6900 TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6901 TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero);
6902 TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6903 TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero);
6904 TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6905 TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero);
6906
6907 END (scalbn);
6908 }
6909
6910
6911 static void
6912 scalbln_test (void)
6913 {
6914
6915 START (scalbln);
6916
6917 TEST_fl_f (scalbln, 0, 0, 0);
6918 TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
6919
6920 TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
6921 TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
6922 TEST_fl_f (scalbln, nan_value, 1, nan_value);
6923
6924 TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
6925 TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
6926
6927 TEST_fl_f (scalbln, 1, 0L, 1);
6928
6929 TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6930 TEST_fi_f (scalbln, 1, INT_MIN, plus_zero);
6931 TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6932 TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero);
6933 TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6934 TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero);
6935 TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6936 TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero);
6937
6938 TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6939 TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero);
6940 TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6941 TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero);
6942 TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6943 TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero);
6944 TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6945 TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero);
6946
6947 #if LONG_MAX >= 0x100000000
6948 TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6949 TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero);
6950 TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6951 TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero);
6952 TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6953 TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero);
6954 TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6955 TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero);
6956 #endif
6957
6958 END (scalbn);
6959 }
6960
6961
6962 static void
6963 signbit_test (void)
6964 {
6965
6966 START (signbit);
6967
6968 TEST_f_b (signbit, 0, 0);
6969 TEST_f_b (signbit, minus_zero, 1);
6970 TEST_f_b (signbit, plus_infty, 0);
6971 TEST_f_b (signbit, minus_infty, 1);
6972
6973 /* signbit (x) != 0 for x < 0. */
6974 TEST_f_b (signbit, -1, 1);
6975 /* signbit (x) == 0 for x >= 0. */
6976 TEST_f_b (signbit, 1, 0);
6977
6978 END (signbit);
6979 }
6980
6981
6982 static void
6983 sin_test (void)
6984 {
6985 errno = 0;
6986 FUNC(sin) (0);
6987 if (errno == ENOSYS)
6988 /* Function not implemented. */
6989 return;
6990
6991 START (sin);
6992
6993 TEST_f_f (sin, 0, 0);
6994 TEST_f_f (sin, minus_zero, minus_zero);
6995 errno = 0;
6996 TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
6997 check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
6998 errno = 0;
6999 TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
7000 check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
7001 errno = 0;
7002 TEST_f_f (sin, nan_value, nan_value);
7003 check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
7004
7005 TEST_f_f (sin, M_PI_6l, 0.5);
7006 TEST_f_f (sin, -M_PI_6l, -0.5);
7007 TEST_f_f (sin, M_PI_2l, 1);
7008 TEST_f_f (sin, -M_PI_2l, -1);
7009 TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
7010
7011 TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
7012 TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
7013
7014 #ifdef TEST_DOUBLE
7015 TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
7016 TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
7017 #endif
7018
7019 #ifndef TEST_FLOAT
7020 TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
7021 TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
7022 #endif
7023
7024 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7025 TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
7026 #endif
7027
7028 END (sin);
7029
7030 }
7031
7032
7033 static void
7034 sin_test_tonearest (void)
7035 {
7036 int save_round_mode;
7037 errno = 0;
7038 FUNC(sin) (0);
7039 if (errno == ENOSYS)
7040 /* Function not implemented. */
7041 return;
7042
7043 START (sin_tonearest);
7044
7045 save_round_mode = fegetround ();
7046
7047 if (!fesetround (FE_TONEAREST))
7048 {
7049 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7050 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7051 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7052 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7053 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7054 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7055 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7056 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7057 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7058 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7059 }
7060
7061 fesetround (save_round_mode);
7062
7063 END (sin_tonearest);
7064 }
7065
7066
7067 static void
7068 sin_test_towardzero (void)
7069 {
7070 int save_round_mode;
7071 errno = 0;
7072 FUNC(sin) (0);
7073 if (errno == ENOSYS)
7074 /* Function not implemented. */
7075 return;
7076
7077 START (sin_towardzero);
7078
7079 save_round_mode = fegetround ();
7080
7081 if (!fesetround (FE_TOWARDZERO))
7082 {
7083 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7084 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7085 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7086 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7087 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7088 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7089 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7090 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7091 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7092 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7093 }
7094
7095 fesetround (save_round_mode);
7096
7097 END (sin_towardzero);
7098 }
7099
7100
7101 static void
7102 sin_test_downward (void)
7103 {
7104 int save_round_mode;
7105 errno = 0;
7106 FUNC(sin) (0);
7107 if (errno == ENOSYS)
7108 /* Function not implemented. */
7109 return;
7110
7111 START (sin_downward);
7112
7113 save_round_mode = fegetround ();
7114
7115 if (!fesetround (FE_DOWNWARD))
7116 {
7117 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7118 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7119 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7120 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7121 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7122 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7123 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7124 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7125 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7126 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7127 }
7128
7129 fesetround (save_round_mode);
7130
7131 END (sin_downward);
7132 }
7133
7134
7135 static void
7136 sin_test_upward (void)
7137 {
7138 int save_round_mode;
7139 errno = 0;
7140 FUNC(sin) (0);
7141 if (errno == ENOSYS)
7142 /* Function not implemented. */
7143 return;
7144
7145 START (sin_upward);
7146
7147 save_round_mode = fegetround ();
7148
7149 if (!fesetround (FE_UPWARD))
7150 {
7151 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7152 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7153 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7154 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7155 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7156 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7157 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7158 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7159 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7160 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7161 }
7162
7163 fesetround (save_round_mode);
7164
7165 END (sin_upward);
7166 }
7167
7168
7169 static void
7170 sincos_test (void)
7171 {
7172 FLOAT sin_res, cos_res;
7173
7174 errno = 0;
7175 FUNC(sincos) (0, &sin_res, &cos_res);
7176 if (errno == ENOSYS)
7177 /* Function not implemented. */
7178 return;
7179
7180 START (sincos);
7181
7182 /* sincos is treated differently because it returns void. */
7183 TEST_extra (sincos, 0, 0, 1);
7184
7185 TEST_extra (sincos, minus_zero, minus_zero, 1);
7186 TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
7187 TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
7188 TEST_extra (sincos, nan_value, nan_value, nan_value);
7189
7190 TEST_extra (sincos, M_PI_2l, 1, 0);
7191 TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
7192 TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
7193 TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
7194
7195 TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
7196 TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
7197
7198 #ifdef TEST_DOUBLE
7199 TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
7200 #endif
7201
7202 #ifndef TEST_FLOAT
7203 TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
7204 TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
7205 #endif
7206
7207 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7208 TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
7209 #endif
7210
7211 END (sincos);
7212 }
7213
7214 static void
7215 sinh_test (void)
7216 {
7217 errno = 0;
7218 FUNC(sinh) (0.7L);
7219 if (errno == ENOSYS)
7220 /* Function not implemented. */
7221 return;
7222
7223 START (sinh);
7224 TEST_f_f (sinh, 0, 0);
7225 TEST_f_f (sinh, minus_zero, minus_zero);
7226
7227 #ifndef TEST_INLINE
7228 TEST_f_f (sinh, plus_infty, plus_infty);
7229 TEST_f_f (sinh, minus_infty, minus_infty);
7230 #endif
7231 TEST_f_f (sinh, nan_value, nan_value);
7232
7233 TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
7234 TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
7235
7236 END (sinh);
7237 }
7238
7239
7240 static void
7241 sinh_test_tonearest (void)
7242 {
7243 int save_round_mode;
7244 errno = 0;
7245 FUNC(sinh) (0);
7246 if (errno == ENOSYS)
7247 /* Function not implemented. */
7248 return;
7249
7250 START (sinh_tonearest);
7251
7252 save_round_mode = fegetround ();
7253
7254 if (!fesetround (FE_TONEAREST))
7255 {
7256 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7257 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7258 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7259 }
7260
7261 fesetround (save_round_mode);
7262
7263 END (sinh_tonearest);
7264 }
7265
7266
7267 static void
7268 sinh_test_towardzero (void)
7269 {
7270 int save_round_mode;
7271 errno = 0;
7272 FUNC(sinh) (0);
7273 if (errno == ENOSYS)
7274 /* Function not implemented. */
7275 return;
7276
7277 START (sinh_towardzero);
7278
7279 save_round_mode = fegetround ();
7280
7281 if (!fesetround (FE_TOWARDZERO))
7282 {
7283 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7284 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7285 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7286 }
7287
7288 fesetround (save_round_mode);
7289
7290 END (sinh_towardzero);
7291 }
7292
7293
7294 static void
7295 sinh_test_downward (void)
7296 {
7297 int save_round_mode;
7298 errno = 0;
7299 FUNC(sinh) (0);
7300 if (errno == ENOSYS)
7301 /* Function not implemented. */
7302 return;
7303
7304 START (sinh_downward);
7305
7306 save_round_mode = fegetround ();
7307
7308 if (!fesetround (FE_DOWNWARD))
7309 {
7310 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7311 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7312 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7313 }
7314
7315 fesetround (save_round_mode);
7316
7317 END (sinh_downward);
7318 }
7319
7320
7321 static void
7322 sinh_test_upward (void)
7323 {
7324 int save_round_mode;
7325 errno = 0;
7326 FUNC(sinh) (0);
7327 if (errno == ENOSYS)
7328 /* Function not implemented. */
7329 return;
7330
7331 START (sinh_upward);
7332
7333 save_round_mode = fegetround ();
7334
7335 if (!fesetround (FE_UPWARD))
7336 {
7337 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7338 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7339 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7340 }
7341
7342 fesetround (save_round_mode);
7343
7344 END (sinh_upward);
7345 }
7346
7347
7348 static void
7349 sqrt_test (void)
7350 {
7351 errno = 0;
7352 FUNC(sqrt) (1);
7353 if (errno == ENOSYS)
7354 /* Function not implemented. */
7355 return;
7356
7357 START (sqrt);
7358
7359 TEST_f_f (sqrt, 0, 0);
7360 TEST_f_f (sqrt, nan_value, nan_value);
7361 TEST_f_f (sqrt, plus_infty, plus_infty);
7362
7363 TEST_f_f (sqrt, minus_zero, minus_zero);
7364
7365 /* sqrt (x) == NaN plus invalid exception for x < 0. */
7366 TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
7367 TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
7368 TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
7369 TEST_f_f (sqrt, nan_value, nan_value);
7370
7371 TEST_f_f (sqrt, 2209, 47);
7372 TEST_f_f (sqrt, 4, 2);
7373 TEST_f_f (sqrt, 2, M_SQRT2l);
7374 TEST_f_f (sqrt, 0.25, 0.5);
7375 TEST_f_f (sqrt, 6642.25, 81.5);
7376 TEST_f_f (sqrt, 15190.5625L, 123.25L);
7377 TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
7378
7379 END (sqrt);
7380 }
7381
7382
7383 static void
7384 tan_test (void)
7385 {
7386 errno = 0;
7387 FUNC(tan) (0);
7388 if (errno == ENOSYS)
7389 /* Function not implemented. */
7390 return;
7391
7392 START (tan);
7393
7394 TEST_f_f (tan, 0, 0);
7395 TEST_f_f (tan, minus_zero, minus_zero);
7396 errno = 0;
7397 TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
7398 check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
7399 errno = 0;
7400 TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
7401 check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
7402 errno = 0;
7403 TEST_f_f (tan, nan_value, nan_value);
7404 check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
7405
7406 TEST_f_f (tan, M_PI_4l, 1);
7407 TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
7408
7409 TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
7410 TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
7411
7412 #ifndef TEST_FLOAT
7413 TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
7414 TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
7415 #endif
7416
7417 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7418 TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
7419 #endif
7420
7421 END (tan);
7422 }
7423
7424
7425 static void
7426 tan_test_tonearest (void)
7427 {
7428 int save_round_mode;
7429 errno = 0;
7430 FUNC(tan) (0);
7431 if (errno == ENOSYS)
7432 /* Function not implemented. */
7433 return;
7434
7435 START (tan_tonearest);
7436
7437 save_round_mode = fegetround ();
7438
7439 if (!fesetround (FE_TONEAREST))
7440 {
7441 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7442 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7443 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7444 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7445 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7446 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7447 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7448 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7449 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7450 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7451 }
7452
7453 fesetround (save_round_mode);
7454
7455 END (tan_tonearest);
7456 }
7457
7458
7459 static void
7460 tan_test_towardzero (void)
7461 {
7462 int save_round_mode;
7463 errno = 0;
7464 FUNC(tan) (0);
7465 if (errno == ENOSYS)
7466 /* Function not implemented. */
7467 return;
7468
7469 START (tan_towardzero);
7470
7471 save_round_mode = fegetround ();
7472
7473 if (!fesetround (FE_TOWARDZERO))
7474 {
7475 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7476 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7477 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7478 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7479 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7480 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7481 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7482 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7483 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7484 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7485 }
7486
7487 fesetround (save_round_mode);
7488
7489 END (tan_towardzero);
7490 }
7491
7492
7493 static void
7494 tan_test_downward (void)
7495 {
7496 int save_round_mode;
7497 errno = 0;
7498 FUNC(tan) (0);
7499 if (errno == ENOSYS)
7500 /* Function not implemented. */
7501 return;
7502
7503 START (tan_downward);
7504
7505 save_round_mode = fegetround ();
7506
7507 if (!fesetround (FE_DOWNWARD))
7508 {
7509 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7510 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7511 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7512 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7513 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7514 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7515 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7516 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7517 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7518 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7519 }
7520
7521 fesetround (save_round_mode);
7522
7523 END (tan_downward);
7524 }
7525
7526
7527 static void
7528 tan_test_upward (void)
7529 {
7530 int save_round_mode;
7531 errno = 0;
7532 FUNC(tan) (0);
7533 if (errno == ENOSYS)
7534 /* Function not implemented. */
7535 return;
7536
7537 START (tan_upward);
7538
7539 save_round_mode = fegetround ();
7540
7541 if (!fesetround (FE_UPWARD))
7542 {
7543 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7544 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7545 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7546 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7547 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7548 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7549 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7550 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7551 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7552 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7553 }
7554
7555 fesetround (save_round_mode);
7556
7557 END (tan_upward);
7558 }
7559
7560
7561 static void
7562 tanh_test (void)
7563 {
7564 errno = 0;
7565 FUNC(tanh) (0.7L);
7566 if (errno == ENOSYS)
7567 /* Function not implemented. */
7568 return;
7569
7570 START (tanh);
7571
7572 TEST_f_f (tanh, 0, 0);
7573 TEST_f_f (tanh, minus_zero, minus_zero);
7574
7575 #ifndef TEST_INLINE
7576 TEST_f_f (tanh, plus_infty, 1);
7577 TEST_f_f (tanh, minus_infty, -1);
7578 #endif
7579 TEST_f_f (tanh, nan_value, nan_value);
7580
7581 TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
7582 TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
7583
7584 TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
7585 TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
7586
7587 /* 2^-57 */
7588 TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
7589
7590 END (tanh);
7591 }
7592
7593 static void
7594 tgamma_test (void)
7595 {
7596 errno = 0;
7597 FUNC(tgamma) (1);
7598 if (errno == ENOSYS)
7599 /* Function not implemented. */
7600 return;
7601 feclearexcept (FE_ALL_EXCEPT);
7602
7603 START (tgamma);
7604
7605 TEST_f_f (tgamma, plus_infty, plus_infty);
7606 TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
7607 TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7608 TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7609 /* tgamma (x) == NaN plus invalid exception for integer x <= 0. */
7610 TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
7611 TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
7612 TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
7613 TEST_f_f (tgamma, nan_value, nan_value);
7614
7615 TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
7616 TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
7617
7618 TEST_f_f (tgamma, 1, 1);
7619 TEST_f_f (tgamma, 4, 6);
7620
7621 TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
7622 TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
7623
7624 END (tgamma);
7625 }
7626
7627
7628 static void
7629 trunc_test (void)
7630 {
7631 START (trunc);
7632
7633 TEST_f_f (trunc, plus_infty, plus_infty);
7634 TEST_f_f (trunc, minus_infty, minus_infty);
7635 TEST_f_f (trunc, nan_value, nan_value);
7636
7637 TEST_f_f (trunc, 0, 0);
7638 TEST_f_f (trunc, minus_zero, minus_zero);
7639 TEST_f_f (trunc, 0.1, 0);
7640 TEST_f_f (trunc, 0.25, 0);
7641 TEST_f_f (trunc, 0.625, 0);
7642 TEST_f_f (trunc, -0.1, minus_zero);
7643 TEST_f_f (trunc, -0.25, minus_zero);
7644 TEST_f_f (trunc, -0.625, minus_zero);
7645 TEST_f_f (trunc, 1, 1);
7646 TEST_f_f (trunc, -1, -1);
7647 TEST_f_f (trunc, 1.625, 1);
7648 TEST_f_f (trunc, -1.625, -1);
7649
7650 TEST_f_f (trunc, 1048580.625L, 1048580L);
7651 TEST_f_f (trunc, -1048580.625L, -1048580L);
7652
7653 TEST_f_f (trunc, 8388610.125L, 8388610.0L);
7654 TEST_f_f (trunc, -8388610.125L, -8388610.0L);
7655
7656 TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
7657 TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
7658
7659 #ifdef TEST_LDOUBLE
7660 /* The result can only be represented in long double. */
7661 TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
7662 TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
7663 TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
7664 TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
7665 TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
7666
7667 # if LDBL_MANT_DIG > 100
7668 TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
7669 TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
7670 TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
7671 # endif
7672
7673 TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
7674 TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
7675 TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
7676 TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
7677 TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
7678
7679 # if LDBL_MANT_DIG > 100
7680 TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
7681 TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
7682 TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
7683 # endif
7684
7685 TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
7686 TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
7687 TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
7688 TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
7689 TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
7690
7691 # if LDBL_MANT_DIG > 100
7692 TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
7693 TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
7694 TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
7695 TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
7696 TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
7697 TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
7698 # endif
7699
7700 TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
7701 TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
7702 TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
7703 TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
7704 TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
7705
7706 # if LDBL_MANT_DIG > 100
7707 TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
7708 TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
7709 TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
7710 TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
7711 TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
7712 TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
7713 # endif
7714
7715 TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
7716 TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
7717 TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
7718 TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
7719 TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
7720
7721 TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
7722 TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
7723 TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
7724 TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
7725 TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
7726
7727 TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
7728 TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7729 TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
7730 TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
7731 TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
7732 #endif
7733
7734 END (trunc);
7735 }
7736
7737 static void
7738 y0_test (void)
7739 {
7740 FLOAT s, c;
7741 errno = 0;
7742 FUNC (sincos) (0, &s, &c);
7743 if (errno == ENOSYS)
7744 /* Required function not implemented. */
7745 return;
7746 FUNC(y0) (1);
7747 if (errno == ENOSYS)
7748 /* Function not implemented. */
7749 return;
7750
7751 /* y0 is the Bessel function of the second kind of order 0 */
7752 START (y0);
7753
7754 TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
7755 TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
7756 TEST_f_f (y0, 0.0, minus_infty);
7757 TEST_f_f (y0, nan_value, nan_value);
7758 TEST_f_f (y0, plus_infty, 0);
7759
7760 TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
7761 TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
7762 TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
7763 TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
7764 TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
7765 TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
7766 TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
7767
7768 TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
7769
7770 #ifndef TEST_FLOAT
7771 TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
7772 #endif
7773
7774 END (y0);
7775 }
7776
7777
7778 static void
7779 y1_test (void)
7780 {
7781 FLOAT s, c;
7782 errno = 0;
7783 FUNC (sincos) (0, &s, &c);
7784 if (errno == ENOSYS)
7785 /* Required function not implemented. */
7786 return;
7787 FUNC(y1) (1);
7788 if (errno == ENOSYS)
7789 /* Function not implemented. */
7790 return;
7791
7792 /* y1 is the Bessel function of the second kind of order 1 */
7793 START (y1);
7794
7795 TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
7796 TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
7797 TEST_f_f (y1, 0.0, minus_infty);
7798 TEST_f_f (y1, plus_infty, 0);
7799 TEST_f_f (y1, nan_value, nan_value);
7800
7801 TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
7802 TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
7803 TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
7804 TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
7805 TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
7806 TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
7807 TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
7808
7809 TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L);
7810
7811 #ifndef TEST_FLOAT
7812 TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L);
7813 #endif
7814
7815 END (y1);
7816 }
7817
7818
7819 static void
7820 yn_test (void)
7821 {
7822 FLOAT s, c;
7823 errno = 0;
7824 FUNC (sincos) (0, &s, &c);
7825 if (errno == ENOSYS)
7826 /* Required function not implemented. */
7827 return;
7828 FUNC(yn) (1, 1);
7829 if (errno == ENOSYS)
7830 /* Function not implemented. */
7831 return;
7832
7833 /* yn is the Bessel function of the second kind of order n */
7834 START (yn);
7835
7836 /* yn (0, x) == y0 (x) */
7837 TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
7838 TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
7839 TEST_ff_f (yn, 0, 0.0, minus_infty);
7840 TEST_ff_f (yn, 0, nan_value, nan_value);
7841 TEST_ff_f (yn, 0, plus_infty, 0);
7842
7843 TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
7844 TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
7845 TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
7846 TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
7847 TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
7848 TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
7849 TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
7850
7851 /* yn (1, x) == y1 (x) */
7852 TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
7853 TEST_ff_f (yn, 1, 0.0, minus_infty);
7854 TEST_ff_f (yn, 1, plus_infty, 0);
7855 TEST_ff_f (yn, 1, nan_value, nan_value);
7856
7857 TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
7858 TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
7859 TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
7860 TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
7861 TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
7862 TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
7863 TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
7864
7865 /* yn (3, x) */
7866 TEST_ff_f (yn, 3, plus_infty, 0);
7867 TEST_ff_f (yn, 3, nan_value, nan_value);
7868
7869 TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
7870 TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
7871 TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
7872 TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
7873 TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
7874
7875 /* yn (10, x) */
7876 TEST_ff_f (yn, 10, plus_infty, 0);
7877 TEST_ff_f (yn, 10, nan_value, nan_value);
7878
7879 TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
7880 TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
7881 TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
7882 TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
7883 TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
7884
7885 END (yn);
7886
7887 }
7888
7889
7890 static void
7891 significand_test (void)
7892 {
7893 /* significand returns the mantissa of the exponential representation. */
7894 START (significand);
7895
7896 TEST_f_f (significand, 4.0, 1.0);
7897 TEST_f_f (significand, 6.0, 1.5);
7898 TEST_f_f (significand, 8.0, 1.0);
7899
7900 END (significand);
7901 }
7902
7903
7904 static void
7905 initialize (void)
7906 {
7907 fpstack_test ("start *init*");
7908 plus_zero = 0.0;
7909 nan_value = plus_zero / plus_zero; /* Suppress GCC warning */
7910
7911 minus_zero = FUNC(copysign) (0.0, -1.0);
7912 plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
7913 HUGE_VALL, HUGE_VAL, HUGE_VALF);
7914 minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
7915 -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
7916 max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7917 LDBL_MAX, DBL_MAX, FLT_MAX);
7918 min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
7919 LDBL_MIN, DBL_MIN, FLT_MIN);
7920
7921 (void) &plus_zero;
7922 (void) &nan_value;
7923 (void) &minus_zero;
7924 (void) &plus_infty;
7925 (void) &minus_infty;
7926 (void) &max_value;
7927 (void) &min_value;
7928
7929 /* Clear all exceptions. From now on we must not get random exceptions. */
7930 feclearexcept (FE_ALL_EXCEPT);
7931
7932 /* Test to make sure we start correctly. */
7933 fpstack_test ("end *init*");
7934 }
7935
7936 /* Definitions of arguments for argp functions. */
7937 static const struct argp_option options[] =
7938 {
7939 { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
7940 { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
7941 { "no-max-error", 'f', NULL, 0,
7942 "Don't output maximal errors of functions"},
7943 { "no-points", 'p', NULL, 0,
7944 "Don't output results of functions invocations"},
7945 { "ignore-max-ulp", 'i', "yes/no", 0,
7946 "Ignore given maximal errors"},
7947 { NULL, 0, NULL, 0, NULL }
7948 };
7949
7950 /* Short description of program. */
7951 static const char doc[] = "Math test suite: " TEST_MSG ;
7952
7953 /* Prototype for option handler. */
7954 static error_t parse_opt (int key, char *arg, struct argp_state *state);
7955
7956 /* Data structure to communicate with argp functions. */
7957 static struct argp argp =
7958 {
7959 options, parse_opt, NULL, doc,
7960 };
7961
7962
7963 /* Handle program arguments. */
7964 static error_t
7965 parse_opt (int key, char *arg, struct argp_state *state)
7966 {
7967 switch (key)
7968 {
7969 case 'f':
7970 output_max_error = 0;
7971 break;
7972 case 'i':
7973 if (strcmp (arg, "yes") == 0)
7974 ignore_max_ulp = 1;
7975 else if (strcmp (arg, "no") == 0)
7976 ignore_max_ulp = 0;
7977 break;
7978 case 'p':
7979 output_points = 0;
7980 break;
7981 case 'u':
7982 output_ulps = 1;
7983 break;
7984 case 'v':
7985 if (optarg)
7986 verbose = (unsigned int) strtoul (optarg, NULL, 0);
7987 else
7988 verbose = 3;
7989 break;
7990 default:
7991 return ARGP_ERR_UNKNOWN;
7992 }
7993 return 0;
7994 }
7995
7996 #if 0
7997 /* function to check our ulp calculation. */
7998 void
7999 check_ulp (void)
8000 {
8001 int i;
8002
8003 FLOAT u, diff, ulp;
8004 /* This gives one ulp. */
8005 u = FUNC(nextafter) (10, 20);
8006 check_equal (10.0, u, 1, &diff, &ulp);
8007 printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
8008
8009 /* This gives one more ulp. */
8010 u = FUNC(nextafter) (u, 20);
8011 check_equal (10.0, u, 2, &diff, &ulp);
8012 printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
8013
8014 /* And now calculate 100 ulp. */
8015 for (i = 2; i < 100; i++)
8016 u = FUNC(nextafter) (u, 20);
8017 check_equal (10.0, u, 100, &diff, &ulp);
8018 printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
8019 }
8020 #endif
8021
8022 int
8023 main (int argc, char **argv)
8024 {
8025
8026 int remaining;
8027
8028 verbose = 1;
8029 output_ulps = 0;
8030 output_max_error = 1;
8031 output_points = 1;
8032 /* XXX set to 0 for releases. */
8033 ignore_max_ulp = 0;
8034
8035 /* Parse and process arguments. */
8036 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
8037
8038 if (remaining != argc)
8039 {
8040 fprintf (stderr, "wrong number of arguments");
8041 argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
8042 exit (EXIT_FAILURE);
8043 }
8044
8045 if (output_ulps)
8046 {
8047 ulps_file = fopen ("ULPs", "a");
8048 if (ulps_file == NULL)
8049 {
8050 perror ("can't open file `ULPs' for writing: ");
8051 exit (1);
8052 }
8053 }
8054
8055
8056 initialize ();
8057 printf (TEST_MSG);
8058
8059 #if 0
8060 check_ulp ();
8061 #endif
8062
8063 /* Keep the tests a wee bit ordered (according to ISO C99). */
8064 /* Classification macros: */
8065 fpclassify_test ();
8066 isfinite_test ();
8067 isnormal_test ();
8068 signbit_test ();
8069
8070 /* Trigonometric functions: */
8071 acos_test ();
8072 asin_test ();
8073 atan_test ();
8074 atan2_test ();
8075 cos_test ();
8076 cos_test_tonearest ();
8077 cos_test_towardzero ();
8078 cos_test_downward ();
8079 cos_test_upward ();
8080 sin_test ();
8081 sin_test_tonearest ();
8082 sin_test_towardzero ();
8083 sin_test_downward ();
8084 sin_test_upward ();
8085 sincos_test ();
8086 tan_test ();
8087 tan_test_tonearest ();
8088 tan_test_towardzero ();
8089 tan_test_downward ();
8090 tan_test_upward ();
8091
8092 /* Hyperbolic functions: */
8093 acosh_test ();
8094 asinh_test ();
8095 atanh_test ();
8096 cosh_test ();
8097 cosh_test_tonearest ();
8098 cosh_test_towardzero ();
8099 cosh_test_downward ();
8100 cosh_test_upward ();
8101 sinh_test ();
8102 sinh_test_tonearest ();
8103 sinh_test_towardzero ();
8104 sinh_test_downward ();
8105 sinh_test_upward ();
8106 tanh_test ();
8107
8108 /* Exponential and logarithmic functions: */
8109 exp_test ();
8110 exp_test_tonearest ();
8111 exp_test_towardzero ();
8112 exp_test_downward ();
8113 exp_test_upward ();
8114 exp10_test ();
8115 exp2_test ();
8116 expm1_test ();
8117 frexp_test ();
8118 ldexp_test ();
8119 log_test ();
8120 log10_test ();
8121 log1p_test ();
8122 log2_test ();
8123 logb_test ();
8124 modf_test ();
8125 ilogb_test ();
8126 scalb_test ();
8127 scalbn_test ();
8128 scalbln_test ();
8129 significand_test ();
8130
8131 /* Power and absolute value functions: */
8132 cbrt_test ();
8133 fabs_test ();
8134 hypot_test ();
8135 pow_test ();
8136 pow_test_tonearest ();
8137 pow_test_towardzero ();
8138 pow_test_downward ();
8139 pow_test_upward ();
8140 sqrt_test ();
8141
8142 /* Error and gamma functions: */
8143 erf_test ();
8144 erfc_test ();
8145 gamma_test ();
8146 lgamma_test ();
8147 tgamma_test ();
8148
8149 /* Nearest integer functions: */
8150 ceil_test ();
8151 floor_test ();
8152 nearbyint_test ();
8153 rint_test ();
8154 rint_test_tonearest ();
8155 rint_test_towardzero ();
8156 rint_test_downward ();
8157 rint_test_upward ();
8158 lrint_test ();
8159 lrint_test_tonearest ();
8160 lrint_test_towardzero ();
8161 lrint_test_downward ();
8162 lrint_test_upward ();
8163 llrint_test ();
8164 llrint_test_tonearest ();
8165 llrint_test_towardzero ();
8166 llrint_test_downward ();
8167 llrint_test_upward ();
8168 round_test ();
8169 lround_test ();
8170 llround_test ();
8171 trunc_test ();
8172
8173 /* Remainder functions: */
8174 fmod_test ();
8175 remainder_test ();
8176 remquo_test ();
8177
8178 /* Manipulation functions: */
8179 copysign_test ();
8180 nextafter_test ();
8181 nexttoward_test ();
8182
8183 /* maximum, minimum and positive difference functions */
8184 fdim_test ();
8185 fmax_test ();
8186 fmin_test ();
8187
8188 /* Multiply and add: */
8189 fma_test ();
8190
8191 /* Complex functions: */
8192 cabs_test ();
8193 cacos_test ();
8194 cacosh_test ();
8195 carg_test ();
8196 casin_test ();
8197 casinh_test ();
8198 catan_test ();
8199 catanh_test ();
8200 ccos_test ();
8201 ccosh_test ();
8202 cexp_test ();
8203 cimag_test ();
8204 clog10_test ();
8205 clog_test ();
8206 conj_test ();
8207 cpow_test ();
8208 cproj_test ();
8209 creal_test ();
8210 csin_test ();
8211 csinh_test ();
8212 csqrt_test ();
8213 ctan_test ();
8214 ctanh_test ();
8215
8216 /* Bessel functions: */
8217 j0_test ();
8218 j1_test ();
8219 jn_test ();
8220 y0_test ();
8221 y1_test ();
8222 yn_test ();
8223
8224 if (output_ulps)
8225 fclose (ulps_file);
8226
8227 printf ("\nTest suite completed:\n");
8228 printf (" %d test cases plus %d tests for exception flags executed.\n",
8229 noTests, noExcTests);
8230 if (noXFails)
8231 printf (" %d expected failures occurred.\n", noXFails);
8232 if (noXPasses)
8233 printf (" %d unexpected passes occurred.\n", noXPasses);
8234 if (noErrors)
8235 {
8236 printf (" %d errors occurred.\n", noErrors);
8237 return 1;
8238 }
8239 printf (" All tests passed successfully.\n");
8240
8241 return 0;
8242 }
8243
8244 /*
8245 * Local Variables:
8246 * mode:c
8247 * End:
8248 */
A mirror of the official glibc repository