]> 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
Avoid overflows from long double functions using __kernel_standard.
[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 END (pow);
5822 }
5823
5824
5825 static void
5826 pow_test_tonearest (void)
5827 {
5828 int save_round_mode;
5829 errno = 0;
5830 FUNC(pow) (0, 0);
5831 if (errno == ENOSYS)
5832 /* Function not implemented. */
5833 return;
5834
5835 START (pow_tonearest);
5836
5837 save_round_mode = fegetround ();
5838
5839 if (!fesetround (FE_TONEAREST))
5840 {
5841 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5842 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5843 }
5844
5845 fesetround (save_round_mode);
5846
5847 END (pow_tonearest);
5848 }
5849
5850
5851 static void
5852 pow_test_towardzero (void)
5853 {
5854 int save_round_mode;
5855 errno = 0;
5856 FUNC(pow) (0, 0);
5857 if (errno == ENOSYS)
5858 /* Function not implemented. */
5859 return;
5860
5861 START (pow_towardzero);
5862
5863 save_round_mode = fegetround ();
5864
5865 if (!fesetround (FE_TOWARDZERO))
5866 {
5867 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5868 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5869 }
5870
5871 fesetround (save_round_mode);
5872
5873 END (pow_towardzero);
5874 }
5875
5876
5877 static void
5878 pow_test_downward (void)
5879 {
5880 int save_round_mode;
5881 errno = 0;
5882 FUNC(pow) (0, 0);
5883 if (errno == ENOSYS)
5884 /* Function not implemented. */
5885 return;
5886
5887 START (pow_downward);
5888
5889 save_round_mode = fegetround ();
5890
5891 if (!fesetround (FE_DOWNWARD))
5892 {
5893 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5894 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5895 }
5896
5897 fesetround (save_round_mode);
5898
5899 END (pow_downward);
5900 }
5901
5902
5903 static void
5904 pow_test_upward (void)
5905 {
5906 int save_round_mode;
5907 errno = 0;
5908 FUNC(pow) (0, 0);
5909 if (errno == ENOSYS)
5910 /* Function not implemented. */
5911 return;
5912
5913 START (pow_upward);
5914
5915 save_round_mode = fegetround ();
5916
5917 if (!fesetround (FE_UPWARD))
5918 {
5919 TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5920 TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5921 }
5922
5923 fesetround (save_round_mode);
5924
5925 END (pow_upward);
5926 }
5927
5928
5929 static void
5930 remainder_test (void)
5931 {
5932 errno = 0;
5933 FUNC(remainder) (1.625, 1.0);
5934 if (errno == ENOSYS)
5935 /* Function not implemented. */
5936 return;
5937
5938 START (remainder);
5939
5940 errno = 0;
5941 TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
5942 check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
5943 errno = 0;
5944 TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
5945 check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
5946 errno = 0;
5947 TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
5948 check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
5949 errno = 0;
5950 TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
5951 check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
5952 errno = 0;
5953 TEST_ff_f (remainder, nan_value, nan_value, nan_value);
5954 check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
5955 errno = 0;
5956 TEST_ff_f (remainder, 0, nan_value, nan_value);
5957 check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
5958 errno = 0;
5959 TEST_ff_f (remainder, nan_value, 0, nan_value);
5960 check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
5961
5962 TEST_ff_f (remainder, 1.625, 1.0, -0.375);
5963 TEST_ff_f (remainder, -1.625, 1.0, 0.375);
5964 TEST_ff_f (remainder, 1.625, -1.0, -0.375);
5965 TEST_ff_f (remainder, -1.625, -1.0, 0.375);
5966 TEST_ff_f (remainder, 5.0, 2.0, 1.0);
5967 TEST_ff_f (remainder, 3.0, 2.0, -1.0);
5968
5969 END (remainder);
5970 }
5971
5972 static void
5973 remquo_test (void)
5974 {
5975 /* x is needed. */
5976 int x;
5977
5978 errno = 0;
5979 FUNC(remquo) (1.625, 1.0, &x);
5980 if (errno == ENOSYS)
5981 /* Function not implemented. */
5982 return;
5983
5984 START (remquo);
5985
5986 TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
5987 TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
5988 TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
5989 TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
5990 TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
5991
5992 TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
5993 TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
5994 TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
5995 TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
5996
5997 TEST_ffI_f1 (remquo, 5, 2, 1, 2);
5998 TEST_ffI_f1 (remquo, 3, 2, -1, 2);
5999
6000 END (remquo);
6001 }
6002
6003 static void
6004 rint_test (void)
6005 {
6006 START (rint);
6007
6008 TEST_f_f (rint, 0.0, 0.0);
6009 TEST_f_f (rint, minus_zero, minus_zero);
6010 TEST_f_f (rint, plus_infty, plus_infty);
6011 TEST_f_f (rint, minus_infty, minus_infty);
6012
6013 /* Default rounding mode is round to even. */
6014 TEST_f_f (rint, 0.5, 0.0);
6015 TEST_f_f (rint, 1.5, 2.0);
6016 TEST_f_f (rint, 2.5, 2.0);
6017 TEST_f_f (rint, 3.5, 4.0);
6018 TEST_f_f (rint, 4.5, 4.0);
6019 TEST_f_f (rint, -0.5, -0.0);
6020 TEST_f_f (rint, -1.5, -2.0);
6021 TEST_f_f (rint, -2.5, -2.0);
6022 TEST_f_f (rint, -3.5, -4.0);
6023 TEST_f_f (rint, -4.5, -4.0);
6024 TEST_f_f (rint, 0.1, 0.0);
6025 TEST_f_f (rint, 0.25, 0.0);
6026 TEST_f_f (rint, 0.625, 1.0);
6027 TEST_f_f (rint, -0.1, -0.0);
6028 TEST_f_f (rint, -0.25, -0.0);
6029 TEST_f_f (rint, -0.625, -1.0);
6030 TEST_f_f (rint, 262144.75, 262145.0);
6031 TEST_f_f (rint, 262142.75, 262143.0);
6032 TEST_f_f (rint, 524286.75, 524287.0);
6033 TEST_f_f (rint, 524288.75, 524289.0);
6034 TEST_f_f (rint, 1048576.75, 1048577.0);
6035 TEST_f_f (rint, 2097152.75, 2097153.0);
6036 TEST_f_f (rint, -1048576.75, -1048577.0);
6037 TEST_f_f (rint, -2097152.75, -2097153.0);
6038 #ifndef TEST_FLOAT
6039 TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6040 TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6041 TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6042 TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6043 TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6044 TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6045 TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6046 TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6047 TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6048 TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6049 #endif
6050 #ifdef TEST_LDOUBLE
6051 /* The result can only be represented in long double. */
6052 TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6053 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6054 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6055 TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6056 TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6057
6058 # if LDBL_MANT_DIG > 100
6059 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6060 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6061 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6062 # endif
6063
6064 TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6065 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6066 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6067 TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6068 TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6069
6070 # if LDBL_MANT_DIG > 100
6071 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6072 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6073 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6074
6075 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6076 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6077 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6078 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6079 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6080 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6081
6082 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6083 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6084 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6085 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6086 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6087 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6088 # endif
6089
6090 TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
6091 TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
6092 TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
6093 TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
6094 TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
6095
6096 TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
6097 TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
6098 TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
6099 TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
6100 TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
6101
6102 TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
6103 TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
6104 TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
6105 TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
6106 TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
6107
6108 TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
6109 TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
6110 TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
6111 TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
6112 TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
6113
6114 TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6115 TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6116 TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
6117 TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6118 TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6119 #endif
6120
6121 END (rint);
6122 }
6123
6124 static void
6125 rint_test_tonearest (void)
6126 {
6127 int save_round_mode;
6128 START (rint_tonearest);
6129
6130 save_round_mode = fegetround ();
6131
6132 if (!fesetround (FE_TONEAREST))
6133 {
6134 TEST_f_f (rint, 2.0, 2.0);
6135 TEST_f_f (rint, 1.5, 2.0);
6136 TEST_f_f (rint, 1.0, 1.0);
6137 TEST_f_f (rint, 0.5, 0.0);
6138 TEST_f_f (rint, 0.0, 0.0);
6139 TEST_f_f (rint, minus_zero, minus_zero);
6140 TEST_f_f (rint, -0.5, -0.0);
6141 TEST_f_f (rint, -1.0, -1.0);
6142 TEST_f_f (rint, -1.5, -2.0);
6143 TEST_f_f (rint, -2.0, -2.0);
6144 TEST_f_f (rint, 0.1, 0.0);
6145 TEST_f_f (rint, 0.25, 0.0);
6146 TEST_f_f (rint, 0.625, 1.0);
6147 TEST_f_f (rint, -0.1, -0.0);
6148 TEST_f_f (rint, -0.25, -0.0);
6149 TEST_f_f (rint, -0.625, -1.0);
6150 TEST_f_f (rint, 1048576.75, 1048577.0);
6151 TEST_f_f (rint, 2097152.75, 2097153.0);
6152 TEST_f_f (rint, -1048576.75, -1048577.0);
6153 TEST_f_f (rint, -2097152.75, -2097153.0);
6154 #ifndef TEST_FLOAT
6155 TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6156 TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6157 TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6158 TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6159 TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6160 TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6161 TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6162 TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6163 TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6164 TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6165 #endif
6166 #ifdef TEST_LDOUBLE
6167 /* The result can only be represented in long double. */
6168 TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6169 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6170 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6171 TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6172 TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6173 # if LDBL_MANT_DIG > 100
6174 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6175 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6176 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6177 # endif
6178 TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6179 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6180 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6181 TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6182 TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6183 # if LDBL_MANT_DIG > 100
6184 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6185 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6186 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6187
6188 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6189 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6190 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6191 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6192 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6193 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6194
6195 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6196 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6197 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6198 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6199 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6200 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6201 # endif
6202 #endif
6203 }
6204
6205 fesetround (save_round_mode);
6206
6207 END (rint_tonearest);
6208 }
6209
6210 static void
6211 rint_test_towardzero (void)
6212 {
6213 int save_round_mode;
6214 START (rint_towardzero);
6215
6216 save_round_mode = fegetround ();
6217
6218 if (!fesetround (FE_TOWARDZERO))
6219 {
6220 TEST_f_f (rint, 2.0, 2.0);
6221 TEST_f_f (rint, 1.5, 1.0);
6222 TEST_f_f (rint, 1.0, 1.0);
6223 TEST_f_f (rint, 0.5, 0.0);
6224 TEST_f_f (rint, 0.0, 0.0);
6225 TEST_f_f (rint, minus_zero, minus_zero);
6226 TEST_f_f (rint, -0.5, -0.0);
6227 TEST_f_f (rint, -1.0, -1.0);
6228 TEST_f_f (rint, -1.5, -1.0);
6229 TEST_f_f (rint, -2.0, -2.0);
6230 TEST_f_f (rint, 0.1, 0.0);
6231 TEST_f_f (rint, 0.25, 0.0);
6232 TEST_f_f (rint, 0.625, 0.0);
6233 TEST_f_f (rint, -0.1, -0.0);
6234 TEST_f_f (rint, -0.25, -0.0);
6235 TEST_f_f (rint, -0.625, -0.0);
6236 TEST_f_f (rint, 1048576.75, 1048576.0);
6237 TEST_f_f (rint, 2097152.75, 2097152.0);
6238 TEST_f_f (rint, -1048576.75, -1048576.0);
6239 TEST_f_f (rint, -2097152.75, -2097152.0);
6240 #ifndef TEST_FLOAT
6241 TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6242 TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6243 TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6244 TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6245 TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6246 TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6247 TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6248 TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6249 TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6250 TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6251 #endif
6252 #ifdef TEST_LDOUBLE
6253 /* The result can only be represented in long double. */
6254 TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6255 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6256 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6257 TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6258 TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6259 # if LDBL_MANT_DIG > 100
6260 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6261 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6262 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6263 # endif
6264 TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6265 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6266 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6267 TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6268 TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6269 # if LDBL_MANT_DIG > 100
6270 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6271 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6272 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6273
6274 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6275 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6276 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6277 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6278 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6279 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6280
6281 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6282 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6283 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6284 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
6285 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6286 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6287 # endif
6288 #endif
6289 }
6290
6291 fesetround (save_round_mode);
6292
6293 END (rint_towardzero);
6294 }
6295
6296 static void
6297 rint_test_downward (void)
6298 {
6299 int save_round_mode;
6300 START (rint_downward);
6301
6302 save_round_mode = fegetround ();
6303
6304 if (!fesetround (FE_DOWNWARD))
6305 {
6306 TEST_f_f (rint, 2.0, 2.0);
6307 TEST_f_f (rint, 1.5, 1.0);
6308 TEST_f_f (rint, 1.0, 1.0);
6309 TEST_f_f (rint, 0.5, 0.0);
6310 TEST_f_f (rint, 0.0, 0.0);
6311 TEST_f_f (rint, minus_zero, minus_zero);
6312 TEST_f_f (rint, -0.5, -1.0);
6313 TEST_f_f (rint, -1.0, -1.0);
6314 TEST_f_f (rint, -1.5, -2.0);
6315 TEST_f_f (rint, -2.0, -2.0);
6316 TEST_f_f (rint, 0.1, 0.0);
6317 TEST_f_f (rint, 0.25, 0.0);
6318 TEST_f_f (rint, 0.625, 0.0);
6319 TEST_f_f (rint, -0.1, -1.0);
6320 TEST_f_f (rint, -0.25, -1.0);
6321 TEST_f_f (rint, -0.625, -1.0);
6322 TEST_f_f (rint, 1048576.75, 1048576.0);
6323 TEST_f_f (rint, 2097152.75, 2097152.0);
6324 TEST_f_f (rint, -1048576.75, -1048577.0);
6325 TEST_f_f (rint, -2097152.75, -2097153.0);
6326 #ifndef TEST_FLOAT
6327 TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6328 TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6329 TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6330 TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6331 TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6332 TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6333 TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6334 TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6335 TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6336 TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6337 #endif
6338 #ifdef TEST_LDOUBLE
6339 /* The result can only be represented in long double. */
6340 TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6341 TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6342 TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6343 TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6344 TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6345 # if LDBL_MANT_DIG > 100
6346 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6347 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6348 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6349 # endif
6350 TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6351 TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
6352 TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
6353 TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6354 TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6355 # if LDBL_MANT_DIG > 100
6356 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6357 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6358 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6359
6360 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6361 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6362 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6363 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6364 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6365 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6366
6367 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
6368 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
6369 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
6370 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6371 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6372 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6373 # endif
6374 #endif
6375 }
6376
6377 fesetround (save_round_mode);
6378
6379 END (rint_downward);
6380 }
6381
6382 static void
6383 rint_test_upward (void)
6384 {
6385 int save_round_mode;
6386 START (rint_upward);
6387
6388 save_round_mode = fegetround ();
6389
6390 if (!fesetround (FE_UPWARD))
6391 {
6392 TEST_f_f (rint, 2.0, 2.0);
6393 TEST_f_f (rint, 1.5, 2.0);
6394 TEST_f_f (rint, 1.0, 1.0);
6395 TEST_f_f (rint, 0.5, 1.0);
6396 TEST_f_f (rint, 0.0, 0.0);
6397 TEST_f_f (rint, minus_zero, minus_zero);
6398 TEST_f_f (rint, -0.5, -0.0);
6399 TEST_f_f (rint, -1.0, -1.0);
6400 TEST_f_f (rint, -1.5, -1.0);
6401 TEST_f_f (rint, -2.0, -2.0);
6402 TEST_f_f (rint, 0.1, 1.0);
6403 TEST_f_f (rint, 0.25, 1.0);
6404 TEST_f_f (rint, 0.625, 1.0);
6405 TEST_f_f (rint, -0.1, -0.0);
6406 TEST_f_f (rint, -0.25, -0.0);
6407 TEST_f_f (rint, -0.625, -0.0);
6408 TEST_f_f (rint, 1048576.75, 1048577.0);
6409 TEST_f_f (rint, 2097152.75, 2097153.0);
6410 TEST_f_f (rint, -1048576.75, -1048576.0);
6411 TEST_f_f (rint, -2097152.75, -2097152.0);
6412 #ifndef TEST_FLOAT
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 TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6419 TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6420 TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6421 TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6422 TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6423 #endif
6424 #ifdef TEST_LDOUBLE
6425 /* The result can only be represented in long double. */
6426 TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6427 TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
6428 TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
6429 TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6430 TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6431 # if LDBL_MANT_DIG > 100
6432 TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6433 TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6434 TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6435 # endif
6436 TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6437 TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6438 TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6439 TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6440 TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6441 # if LDBL_MANT_DIG > 100
6442 TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6443 TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6444 TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6445
6446 TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
6447 TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
6448 TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
6449 TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6450 TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6451 TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6452
6453 TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6454 TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6455 TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6456 TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
6457 TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6458 TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6459 # endif
6460 #endif
6461 }
6462
6463 fesetround (save_round_mode);
6464
6465 END (rint_upward);
6466 }
6467
6468 static void
6469 round_test (void)
6470 {
6471 START (round);
6472
6473 TEST_f_f (round, 0, 0);
6474 TEST_f_f (round, minus_zero, minus_zero);
6475 TEST_f_f (round, 0.2L, 0.0);
6476 TEST_f_f (round, -0.2L, minus_zero);
6477 TEST_f_f (round, 0.5, 1.0);
6478 TEST_f_f (round, -0.5, -1.0);
6479 TEST_f_f (round, 0.8L, 1.0);
6480 TEST_f_f (round, -0.8L, -1.0);
6481 TEST_f_f (round, 1.5, 2.0);
6482 TEST_f_f (round, -1.5, -2.0);
6483 TEST_f_f (round, 0.1, 0.0);
6484 TEST_f_f (round, 0.25, 0.0);
6485 TEST_f_f (round, 0.625, 1.0);
6486 TEST_f_f (round, -0.1, -0.0);
6487 TEST_f_f (round, -0.25, -0.0);
6488 TEST_f_f (round, -0.625, -1.0);
6489 TEST_f_f (round, 2097152.5, 2097153);
6490 TEST_f_f (round, -2097152.5, -2097153);
6491
6492 #ifdef TEST_LDOUBLE
6493 /* The result can only be represented in long double. */
6494 TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
6495 TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
6496 TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
6497 TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
6498 TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
6499 # if LDBL_MANT_DIG > 100
6500 TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
6501 TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
6502 TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
6503 # endif
6504
6505 TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
6506 TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
6507 TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
6508 TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
6509 TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
6510 # if LDBL_MANT_DIG > 100
6511 TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
6512 TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
6513 TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
6514 # endif
6515
6516 TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
6517 TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
6518 TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
6519 TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
6520 TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
6521
6522 TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
6523 TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
6524 TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
6525 TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
6526 TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
6527
6528 # if LDBL_MANT_DIG > 100
6529 TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
6530 TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
6531 TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
6532 TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
6533 TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
6534 TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
6535
6536 TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
6537 TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
6538 TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
6539 TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
6540 TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
6541 TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
6542 # endif
6543
6544 TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
6545 TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
6546 TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
6547 TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
6548 TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
6549
6550 TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
6551 TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
6552 TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
6553 TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
6554 TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
6555
6556 TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6557 TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6558 TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
6559 TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6560 TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6561 #endif
6562
6563 END (round);
6564 }
6565
6566
6567 static void
6568 scalb_test (void)
6569 {
6570
6571 START (scalb);
6572
6573 TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
6574 TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
6575
6576 TEST_ff_f (scalb, 0, nan_value, nan_value);
6577 TEST_ff_f (scalb, 1, nan_value, nan_value);
6578
6579 TEST_ff_f (scalb, 1, 0, 1);
6580 TEST_ff_f (scalb, -1, 0, -1);
6581
6582 TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
6583 TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
6584
6585 TEST_ff_f (scalb, 0, 2, 0);
6586 TEST_ff_f (scalb, minus_zero, -4, minus_zero);
6587 TEST_ff_f (scalb, 0, 0, 0);
6588 TEST_ff_f (scalb, minus_zero, 0, minus_zero);
6589 TEST_ff_f (scalb, 0, -1, 0);
6590 TEST_ff_f (scalb, minus_zero, -10, minus_zero);
6591 TEST_ff_f (scalb, 0, minus_infty, 0);
6592 TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
6593
6594 TEST_ff_f (scalb, plus_infty, -1, plus_infty);
6595 TEST_ff_f (scalb, minus_infty, -10, minus_infty);
6596 TEST_ff_f (scalb, plus_infty, 0, plus_infty);
6597 TEST_ff_f (scalb, minus_infty, 0, minus_infty);
6598 TEST_ff_f (scalb, plus_infty, 2, plus_infty);
6599 TEST_ff_f (scalb, minus_infty, 100, minus_infty);
6600
6601 TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
6602 TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
6603
6604 TEST_ff_f (scalb, 1, plus_infty, plus_infty);
6605 TEST_ff_f (scalb, -1, plus_infty, minus_infty);
6606 TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
6607 TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
6608
6609 TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6610 TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6611
6612 TEST_ff_f (scalb, nan_value, 1, nan_value);
6613 TEST_ff_f (scalb, 1, nan_value, nan_value);
6614 TEST_ff_f (scalb, nan_value, 0, nan_value);
6615 TEST_ff_f (scalb, 0, nan_value, nan_value);
6616 TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
6617 TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
6618 TEST_ff_f (scalb, nan_value, nan_value, nan_value);
6619
6620 TEST_ff_f (scalb, 0.8L, 4, 12.8L);
6621 TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
6622
6623 END (scalb);
6624 }
6625
6626
6627 static void
6628 scalbn_test (void)
6629 {
6630
6631 START (scalbn);
6632
6633 TEST_fi_f (scalbn, 0, 0, 0);
6634 TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
6635
6636 TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
6637 TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
6638 TEST_fi_f (scalbn, nan_value, 1, nan_value);
6639
6640 TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
6641 TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
6642
6643 TEST_fi_f (scalbn, 1, 0L, 1);
6644
6645 TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6646 TEST_fi_f (scalbn, 1, INT_MIN, plus_zero);
6647 TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6648 TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero);
6649 TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6650 TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero);
6651 TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6652 TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero);
6653
6654 END (scalbn);
6655 }
6656
6657
6658 static void
6659 scalbln_test (void)
6660 {
6661
6662 START (scalbln);
6663
6664 TEST_fl_f (scalbln, 0, 0, 0);
6665 TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
6666
6667 TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
6668 TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
6669 TEST_fl_f (scalbln, nan_value, 1, nan_value);
6670
6671 TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
6672 TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
6673
6674 TEST_fl_f (scalbln, 1, 0L, 1);
6675
6676 TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6677 TEST_fi_f (scalbln, 1, INT_MIN, plus_zero);
6678 TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6679 TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero);
6680 TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6681 TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero);
6682 TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6683 TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero);
6684
6685 TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6686 TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero);
6687 TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6688 TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero);
6689 TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6690 TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero);
6691 TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6692 TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero);
6693
6694 #if LONG_MAX >= 0x100000000
6695 TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6696 TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero);
6697 TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6698 TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero);
6699 TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6700 TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero);
6701 TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6702 TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero);
6703 #endif
6704
6705 END (scalbn);
6706 }
6707
6708
6709 static void
6710 signbit_test (void)
6711 {
6712
6713 START (signbit);
6714
6715 TEST_f_b (signbit, 0, 0);
6716 TEST_f_b (signbit, minus_zero, 1);
6717 TEST_f_b (signbit, plus_infty, 0);
6718 TEST_f_b (signbit, minus_infty, 1);
6719
6720 /* signbit (x) != 0 for x < 0. */
6721 TEST_f_b (signbit, -1, 1);
6722 /* signbit (x) == 0 for x >= 0. */
6723 TEST_f_b (signbit, 1, 0);
6724
6725 END (signbit);
6726 }
6727
6728
6729 static void
6730 sin_test (void)
6731 {
6732 errno = 0;
6733 FUNC(sin) (0);
6734 if (errno == ENOSYS)
6735 /* Function not implemented. */
6736 return;
6737
6738 START (sin);
6739
6740 TEST_f_f (sin, 0, 0);
6741 TEST_f_f (sin, minus_zero, minus_zero);
6742 errno = 0;
6743 TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
6744 check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
6745 errno = 0;
6746 TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
6747 check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
6748 errno = 0;
6749 TEST_f_f (sin, nan_value, nan_value);
6750 check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
6751
6752 TEST_f_f (sin, M_PI_6l, 0.5);
6753 TEST_f_f (sin, -M_PI_6l, -0.5);
6754 TEST_f_f (sin, M_PI_2l, 1);
6755 TEST_f_f (sin, -M_PI_2l, -1);
6756 TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
6757
6758 TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
6759 TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
6760
6761 #ifdef TEST_DOUBLE
6762 TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
6763 TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
6764 #endif
6765
6766 #ifndef TEST_FLOAT
6767 TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
6768 TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
6769 #endif
6770
6771 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
6772 TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
6773 #endif
6774
6775 END (sin);
6776
6777 }
6778
6779
6780 static void
6781 sin_test_tonearest (void)
6782 {
6783 int save_round_mode;
6784 errno = 0;
6785 FUNC(sin) (0);
6786 if (errno == ENOSYS)
6787 /* Function not implemented. */
6788 return;
6789
6790 START (sin_tonearest);
6791
6792 save_round_mode = fegetround ();
6793
6794 if (!fesetround (FE_TONEAREST))
6795 {
6796 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6797 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6798 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6799 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6800 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6801 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6802 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6803 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6804 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6805 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6806 }
6807
6808 fesetround (save_round_mode);
6809
6810 END (sin_tonearest);
6811 }
6812
6813
6814 static void
6815 sin_test_towardzero (void)
6816 {
6817 int save_round_mode;
6818 errno = 0;
6819 FUNC(sin) (0);
6820 if (errno == ENOSYS)
6821 /* Function not implemented. */
6822 return;
6823
6824 START (sin_towardzero);
6825
6826 save_round_mode = fegetround ();
6827
6828 if (!fesetround (FE_TOWARDZERO))
6829 {
6830 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6831 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6832 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6833 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6834 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6835 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6836 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6837 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6838 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6839 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6840 }
6841
6842 fesetround (save_round_mode);
6843
6844 END (sin_towardzero);
6845 }
6846
6847
6848 static void
6849 sin_test_downward (void)
6850 {
6851 int save_round_mode;
6852 errno = 0;
6853 FUNC(sin) (0);
6854 if (errno == ENOSYS)
6855 /* Function not implemented. */
6856 return;
6857
6858 START (sin_downward);
6859
6860 save_round_mode = fegetround ();
6861
6862 if (!fesetround (FE_DOWNWARD))
6863 {
6864 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6865 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6866 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6867 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6868 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6869 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6870 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6871 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6872 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6873 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6874 }
6875
6876 fesetround (save_round_mode);
6877
6878 END (sin_downward);
6879 }
6880
6881
6882 static void
6883 sin_test_upward (void)
6884 {
6885 int save_round_mode;
6886 errno = 0;
6887 FUNC(sin) (0);
6888 if (errno == ENOSYS)
6889 /* Function not implemented. */
6890 return;
6891
6892 START (sin_upward);
6893
6894 save_round_mode = fegetround ();
6895
6896 if (!fesetround (FE_UPWARD))
6897 {
6898 TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6899 TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6900 TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6901 TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6902 TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6903 TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6904 TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6905 TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6906 TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6907 TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6908 }
6909
6910 fesetround (save_round_mode);
6911
6912 END (sin_upward);
6913 }
6914
6915
6916 static void
6917 sincos_test (void)
6918 {
6919 FLOAT sin_res, cos_res;
6920
6921 errno = 0;
6922 FUNC(sincos) (0, &sin_res, &cos_res);
6923 if (errno == ENOSYS)
6924 /* Function not implemented. */
6925 return;
6926
6927 START (sincos);
6928
6929 /* sincos is treated differently because it returns void. */
6930 TEST_extra (sincos, 0, 0, 1);
6931
6932 TEST_extra (sincos, minus_zero, minus_zero, 1);
6933 TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
6934 TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
6935 TEST_extra (sincos, nan_value, nan_value, nan_value);
6936
6937 TEST_extra (sincos, M_PI_2l, 1, 0);
6938 TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
6939 TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
6940 TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
6941
6942 TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
6943 TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
6944
6945 #ifdef TEST_DOUBLE
6946 TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
6947 #endif
6948
6949 #ifndef TEST_FLOAT
6950 TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
6951 TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
6952 #endif
6953
6954 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
6955 TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
6956 #endif
6957
6958 END (sincos);
6959 }
6960
6961 static void
6962 sinh_test (void)
6963 {
6964 errno = 0;
6965 FUNC(sinh) (0.7L);
6966 if (errno == ENOSYS)
6967 /* Function not implemented. */
6968 return;
6969
6970 START (sinh);
6971 TEST_f_f (sinh, 0, 0);
6972 TEST_f_f (sinh, minus_zero, minus_zero);
6973
6974 #ifndef TEST_INLINE
6975 TEST_f_f (sinh, plus_infty, plus_infty);
6976 TEST_f_f (sinh, minus_infty, minus_infty);
6977 #endif
6978 TEST_f_f (sinh, nan_value, nan_value);
6979
6980 TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
6981 TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
6982
6983 END (sinh);
6984 }
6985
6986
6987 static void
6988 sinh_test_tonearest (void)
6989 {
6990 int save_round_mode;
6991 errno = 0;
6992 FUNC(sinh) (0);
6993 if (errno == ENOSYS)
6994 /* Function not implemented. */
6995 return;
6996
6997 START (sinh_tonearest);
6998
6999 save_round_mode = fegetround ();
7000
7001 if (!fesetround (FE_TONEAREST))
7002 {
7003 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7004 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7005 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7006 }
7007
7008 fesetround (save_round_mode);
7009
7010 END (sinh_tonearest);
7011 }
7012
7013
7014 static void
7015 sinh_test_towardzero (void)
7016 {
7017 int save_round_mode;
7018 errno = 0;
7019 FUNC(sinh) (0);
7020 if (errno == ENOSYS)
7021 /* Function not implemented. */
7022 return;
7023
7024 START (sinh_towardzero);
7025
7026 save_round_mode = fegetround ();
7027
7028 if (!fesetround (FE_TOWARDZERO))
7029 {
7030 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7031 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7032 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7033 }
7034
7035 fesetround (save_round_mode);
7036
7037 END (sinh_towardzero);
7038 }
7039
7040
7041 static void
7042 sinh_test_downward (void)
7043 {
7044 int save_round_mode;
7045 errno = 0;
7046 FUNC(sinh) (0);
7047 if (errno == ENOSYS)
7048 /* Function not implemented. */
7049 return;
7050
7051 START (sinh_downward);
7052
7053 save_round_mode = fegetround ();
7054
7055 if (!fesetround (FE_DOWNWARD))
7056 {
7057 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7058 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7059 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7060 }
7061
7062 fesetround (save_round_mode);
7063
7064 END (sinh_downward);
7065 }
7066
7067
7068 static void
7069 sinh_test_upward (void)
7070 {
7071 int save_round_mode;
7072 errno = 0;
7073 FUNC(sinh) (0);
7074 if (errno == ENOSYS)
7075 /* Function not implemented. */
7076 return;
7077
7078 START (sinh_upward);
7079
7080 save_round_mode = fegetround ();
7081
7082 if (!fesetround (FE_UPWARD))
7083 {
7084 TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7085 TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7086 TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7087 }
7088
7089 fesetround (save_round_mode);
7090
7091 END (sinh_upward);
7092 }
7093
7094
7095 static void
7096 sqrt_test (void)
7097 {
7098 errno = 0;
7099 FUNC(sqrt) (1);
7100 if (errno == ENOSYS)
7101 /* Function not implemented. */
7102 return;
7103
7104 START (sqrt);
7105
7106 TEST_f_f (sqrt, 0, 0);
7107 TEST_f_f (sqrt, nan_value, nan_value);
7108 TEST_f_f (sqrt, plus_infty, plus_infty);
7109
7110 TEST_f_f (sqrt, minus_zero, minus_zero);
7111
7112 /* sqrt (x) == NaN plus invalid exception for x < 0. */
7113 TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
7114 TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
7115 TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
7116 TEST_f_f (sqrt, nan_value, nan_value);
7117
7118 TEST_f_f (sqrt, 2209, 47);
7119 TEST_f_f (sqrt, 4, 2);
7120 TEST_f_f (sqrt, 2, M_SQRT2l);
7121 TEST_f_f (sqrt, 0.25, 0.5);
7122 TEST_f_f (sqrt, 6642.25, 81.5);
7123 TEST_f_f (sqrt, 15190.5625L, 123.25L);
7124 TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
7125
7126 END (sqrt);
7127 }
7128
7129
7130 static void
7131 tan_test (void)
7132 {
7133 errno = 0;
7134 FUNC(tan) (0);
7135 if (errno == ENOSYS)
7136 /* Function not implemented. */
7137 return;
7138
7139 START (tan);
7140
7141 TEST_f_f (tan, 0, 0);
7142 TEST_f_f (tan, minus_zero, minus_zero);
7143 errno = 0;
7144 TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
7145 check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
7146 errno = 0;
7147 TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
7148 check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
7149 errno = 0;
7150 TEST_f_f (tan, nan_value, nan_value);
7151 check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
7152
7153 TEST_f_f (tan, M_PI_4l, 1);
7154 TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
7155
7156 TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
7157 TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
7158
7159 #ifndef TEST_FLOAT
7160 TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
7161 TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
7162 #endif
7163
7164 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7165 TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
7166 #endif
7167
7168 END (tan);
7169 }
7170
7171
7172 static void
7173 tan_test_tonearest (void)
7174 {
7175 int save_round_mode;
7176 errno = 0;
7177 FUNC(tan) (0);
7178 if (errno == ENOSYS)
7179 /* Function not implemented. */
7180 return;
7181
7182 START (tan_tonearest);
7183
7184 save_round_mode = fegetround ();
7185
7186 if (!fesetround (FE_TONEAREST))
7187 {
7188 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7189 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7190 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7191 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7192 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7193 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7194 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7195 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7196 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7197 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7198 }
7199
7200 fesetround (save_round_mode);
7201
7202 END (tan_tonearest);
7203 }
7204
7205
7206 static void
7207 tan_test_towardzero (void)
7208 {
7209 int save_round_mode;
7210 errno = 0;
7211 FUNC(tan) (0);
7212 if (errno == ENOSYS)
7213 /* Function not implemented. */
7214 return;
7215
7216 START (tan_towardzero);
7217
7218 save_round_mode = fegetround ();
7219
7220 if (!fesetround (FE_TOWARDZERO))
7221 {
7222 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7223 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7224 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7225 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7226 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7227 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7228 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7229 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7230 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7231 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7232 }
7233
7234 fesetround (save_round_mode);
7235
7236 END (tan_towardzero);
7237 }
7238
7239
7240 static void
7241 tan_test_downward (void)
7242 {
7243 int save_round_mode;
7244 errno = 0;
7245 FUNC(tan) (0);
7246 if (errno == ENOSYS)
7247 /* Function not implemented. */
7248 return;
7249
7250 START (tan_downward);
7251
7252 save_round_mode = fegetround ();
7253
7254 if (!fesetround (FE_DOWNWARD))
7255 {
7256 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7257 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7258 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7259 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7260 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7261 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7262 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7263 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7264 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7265 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7266 }
7267
7268 fesetround (save_round_mode);
7269
7270 END (tan_downward);
7271 }
7272
7273
7274 static void
7275 tan_test_upward (void)
7276 {
7277 int save_round_mode;
7278 errno = 0;
7279 FUNC(tan) (0);
7280 if (errno == ENOSYS)
7281 /* Function not implemented. */
7282 return;
7283
7284 START (tan_upward);
7285
7286 save_round_mode = fegetround ();
7287
7288 if (!fesetround (FE_UPWARD))
7289 {
7290 TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7291 TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7292 TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7293 TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7294 TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7295 TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7296 TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7297 TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7298 TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7299 TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7300 }
7301
7302 fesetround (save_round_mode);
7303
7304 END (tan_upward);
7305 }
7306
7307
7308 static void
7309 tanh_test (void)
7310 {
7311 errno = 0;
7312 FUNC(tanh) (0.7L);
7313 if (errno == ENOSYS)
7314 /* Function not implemented. */
7315 return;
7316
7317 START (tanh);
7318
7319 TEST_f_f (tanh, 0, 0);
7320 TEST_f_f (tanh, minus_zero, minus_zero);
7321
7322 #ifndef TEST_INLINE
7323 TEST_f_f (tanh, plus_infty, 1);
7324 TEST_f_f (tanh, minus_infty, -1);
7325 #endif
7326 TEST_f_f (tanh, nan_value, nan_value);
7327
7328 TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
7329 TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
7330
7331 TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
7332 TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
7333
7334 /* 2^-57 */
7335 TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
7336
7337 END (tanh);
7338 }
7339
7340 static void
7341 tgamma_test (void)
7342 {
7343 errno = 0;
7344 FUNC(tgamma) (1);
7345 if (errno == ENOSYS)
7346 /* Function not implemented. */
7347 return;
7348 feclearexcept (FE_ALL_EXCEPT);
7349
7350 START (tgamma);
7351
7352 TEST_f_f (tgamma, plus_infty, plus_infty);
7353 TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
7354 TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7355 TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7356 /* tgamma (x) == NaN plus invalid exception for integer x <= 0. */
7357 TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
7358 TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
7359 TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
7360 TEST_f_f (tgamma, nan_value, nan_value);
7361
7362 TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
7363 TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
7364
7365 TEST_f_f (tgamma, 1, 1);
7366 TEST_f_f (tgamma, 4, 6);
7367
7368 TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
7369 TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
7370
7371 END (tgamma);
7372 }
7373
7374
7375 static void
7376 trunc_test (void)
7377 {
7378 START (trunc);
7379
7380 TEST_f_f (trunc, plus_infty, plus_infty);
7381 TEST_f_f (trunc, minus_infty, minus_infty);
7382 TEST_f_f (trunc, nan_value, nan_value);
7383
7384 TEST_f_f (trunc, 0, 0);
7385 TEST_f_f (trunc, minus_zero, minus_zero);
7386 TEST_f_f (trunc, 0.1, 0);
7387 TEST_f_f (trunc, 0.25, 0);
7388 TEST_f_f (trunc, 0.625, 0);
7389 TEST_f_f (trunc, -0.1, minus_zero);
7390 TEST_f_f (trunc, -0.25, minus_zero);
7391 TEST_f_f (trunc, -0.625, minus_zero);
7392 TEST_f_f (trunc, 1, 1);
7393 TEST_f_f (trunc, -1, -1);
7394 TEST_f_f (trunc, 1.625, 1);
7395 TEST_f_f (trunc, -1.625, -1);
7396
7397 TEST_f_f (trunc, 1048580.625L, 1048580L);
7398 TEST_f_f (trunc, -1048580.625L, -1048580L);
7399
7400 TEST_f_f (trunc, 8388610.125L, 8388610.0L);
7401 TEST_f_f (trunc, -8388610.125L, -8388610.0L);
7402
7403 TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
7404 TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
7405
7406 #ifdef TEST_LDOUBLE
7407 /* The result can only be represented in long double. */
7408 TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
7409 TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
7410 TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
7411 TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
7412 TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
7413
7414 # if LDBL_MANT_DIG > 100
7415 TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
7416 TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
7417 TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
7418 # endif
7419
7420 TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
7421 TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
7422 TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
7423 TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
7424 TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
7425
7426 # if LDBL_MANT_DIG > 100
7427 TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
7428 TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
7429 TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
7430 # endif
7431
7432 TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
7433 TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
7434 TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
7435 TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
7436 TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
7437
7438 # if LDBL_MANT_DIG > 100
7439 TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
7440 TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
7441 TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
7442 TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
7443 TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
7444 TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
7445 # endif
7446
7447 TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
7448 TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
7449 TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
7450 TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
7451 TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
7452
7453 # if LDBL_MANT_DIG > 100
7454 TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
7455 TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
7456 TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
7457 TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
7458 TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
7459 TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
7460 # endif
7461
7462 TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
7463 TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
7464 TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
7465 TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
7466 TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
7467
7468 TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
7469 TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
7470 TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
7471 TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
7472 TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
7473
7474 TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
7475 TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7476 TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
7477 TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
7478 TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
7479 #endif
7480
7481 END (trunc);
7482 }
7483
7484 static void
7485 y0_test (void)
7486 {
7487 FLOAT s, c;
7488 errno = 0;
7489 FUNC (sincos) (0, &s, &c);
7490 if (errno == ENOSYS)
7491 /* Required function not implemented. */
7492 return;
7493 FUNC(y0) (1);
7494 if (errno == ENOSYS)
7495 /* Function not implemented. */
7496 return;
7497
7498 /* y0 is the Bessel function of the second kind of order 0 */
7499 START (y0);
7500
7501 TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
7502 TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
7503 TEST_f_f (y0, 0.0, minus_infty);
7504 TEST_f_f (y0, nan_value, nan_value);
7505 TEST_f_f (y0, plus_infty, 0);
7506
7507 TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
7508 TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
7509 TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
7510 TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
7511 TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
7512 TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
7513 TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
7514
7515 TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
7516
7517 #ifndef TEST_FLOAT
7518 TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
7519 #endif
7520
7521 END (y0);
7522 }
7523
7524
7525 static void
7526 y1_test (void)
7527 {
7528 FLOAT s, c;
7529 errno = 0;
7530 FUNC (sincos) (0, &s, &c);
7531 if (errno == ENOSYS)
7532 /* Required function not implemented. */
7533 return;
7534 FUNC(y1) (1);
7535 if (errno == ENOSYS)
7536 /* Function not implemented. */
7537 return;
7538
7539 /* y1 is the Bessel function of the second kind of order 1 */
7540 START (y1);
7541
7542 TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
7543 TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
7544 TEST_f_f (y1, 0.0, minus_infty);
7545 TEST_f_f (y1, plus_infty, 0);
7546 TEST_f_f (y1, nan_value, nan_value);
7547
7548 TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
7549 TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
7550 TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
7551 TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
7552 TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
7553 TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
7554 TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
7555
7556 TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L);
7557
7558 #ifndef TEST_FLOAT
7559 TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L);
7560 #endif
7561
7562 END (y1);
7563 }
7564
7565
7566 static void
7567 yn_test (void)
7568 {
7569 FLOAT s, c;
7570 errno = 0;
7571 FUNC (sincos) (0, &s, &c);
7572 if (errno == ENOSYS)
7573 /* Required function not implemented. */
7574 return;
7575 FUNC(yn) (1, 1);
7576 if (errno == ENOSYS)
7577 /* Function not implemented. */
7578 return;
7579
7580 /* yn is the Bessel function of the second kind of order n */
7581 START (yn);
7582
7583 /* yn (0, x) == y0 (x) */
7584 TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
7585 TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
7586 TEST_ff_f (yn, 0, 0.0, minus_infty);
7587 TEST_ff_f (yn, 0, nan_value, nan_value);
7588 TEST_ff_f (yn, 0, plus_infty, 0);
7589
7590 TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
7591 TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
7592 TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
7593 TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
7594 TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
7595 TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
7596 TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
7597
7598 /* yn (1, x) == y1 (x) */
7599 TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
7600 TEST_ff_f (yn, 1, 0.0, minus_infty);
7601 TEST_ff_f (yn, 1, plus_infty, 0);
7602 TEST_ff_f (yn, 1, nan_value, nan_value);
7603
7604 TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
7605 TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
7606 TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
7607 TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
7608 TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
7609 TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
7610 TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
7611
7612 /* yn (3, x) */
7613 TEST_ff_f (yn, 3, plus_infty, 0);
7614 TEST_ff_f (yn, 3, nan_value, nan_value);
7615
7616 TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
7617 TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
7618 TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
7619 TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
7620 TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
7621
7622 /* yn (10, x) */
7623 TEST_ff_f (yn, 10, plus_infty, 0);
7624 TEST_ff_f (yn, 10, nan_value, nan_value);
7625
7626 TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
7627 TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
7628 TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
7629 TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
7630 TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
7631
7632 END (yn);
7633
7634 }
7635
7636
7637 static void
7638 significand_test (void)
7639 {
7640 /* significand returns the mantissa of the exponential representation. */
7641 START (significand);
7642
7643 TEST_f_f (significand, 4.0, 1.0);
7644 TEST_f_f (significand, 6.0, 1.5);
7645 TEST_f_f (significand, 8.0, 1.0);
7646
7647 END (significand);
7648 }
7649
7650
7651 static void
7652 initialize (void)
7653 {
7654 fpstack_test ("start *init*");
7655 plus_zero = 0.0;
7656 nan_value = plus_zero / plus_zero; /* Suppress GCC warning */
7657
7658 minus_zero = FUNC(copysign) (0.0, -1.0);
7659 plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
7660 HUGE_VALL, HUGE_VAL, HUGE_VALF);
7661 minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
7662 -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
7663 max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7664 LDBL_MAX, DBL_MAX, FLT_MAX);
7665 min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
7666 LDBL_MIN, DBL_MIN, FLT_MIN);
7667
7668 (void) &plus_zero;
7669 (void) &nan_value;
7670 (void) &minus_zero;
7671 (void) &plus_infty;
7672 (void) &minus_infty;
7673 (void) &max_value;
7674 (void) &min_value;
7675
7676 /* Clear all exceptions. From now on we must not get random exceptions. */
7677 feclearexcept (FE_ALL_EXCEPT);
7678
7679 /* Test to make sure we start correctly. */
7680 fpstack_test ("end *init*");
7681 }
7682
7683 /* Definitions of arguments for argp functions. */
7684 static const struct argp_option options[] =
7685 {
7686 { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
7687 { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
7688 { "no-max-error", 'f', NULL, 0,
7689 "Don't output maximal errors of functions"},
7690 { "no-points", 'p', NULL, 0,
7691 "Don't output results of functions invocations"},
7692 { "ignore-max-ulp", 'i', "yes/no", 0,
7693 "Ignore given maximal errors"},
7694 { NULL, 0, NULL, 0, NULL }
7695 };
7696
7697 /* Short description of program. */
7698 static const char doc[] = "Math test suite: " TEST_MSG ;
7699
7700 /* Prototype for option handler. */
7701 static error_t parse_opt (int key, char *arg, struct argp_state *state);
7702
7703 /* Data structure to communicate with argp functions. */
7704 static struct argp argp =
7705 {
7706 options, parse_opt, NULL, doc,
7707 };
7708
7709
7710 /* Handle program arguments. */
7711 static error_t
7712 parse_opt (int key, char *arg, struct argp_state *state)
7713 {
7714 switch (key)
7715 {
7716 case 'f':
7717 output_max_error = 0;
7718 break;
7719 case 'i':
7720 if (strcmp (arg, "yes") == 0)
7721 ignore_max_ulp = 1;
7722 else if (strcmp (arg, "no") == 0)
7723 ignore_max_ulp = 0;
7724 break;
7725 case 'p':
7726 output_points = 0;
7727 break;
7728 case 'u':
7729 output_ulps = 1;
7730 break;
7731 case 'v':
7732 if (optarg)
7733 verbose = (unsigned int) strtoul (optarg, NULL, 0);
7734 else
7735 verbose = 3;
7736 break;
7737 default:
7738 return ARGP_ERR_UNKNOWN;
7739 }
7740 return 0;
7741 }
7742
7743 #if 0
7744 /* function to check our ulp calculation. */
7745 void
7746 check_ulp (void)
7747 {
7748 int i;
7749
7750 FLOAT u, diff, ulp;
7751 /* This gives one ulp. */
7752 u = FUNC(nextafter) (10, 20);
7753 check_equal (10.0, u, 1, &diff, &ulp);
7754 printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
7755
7756 /* This gives one more ulp. */
7757 u = FUNC(nextafter) (u, 20);
7758 check_equal (10.0, u, 2, &diff, &ulp);
7759 printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
7760
7761 /* And now calculate 100 ulp. */
7762 for (i = 2; i < 100; i++)
7763 u = FUNC(nextafter) (u, 20);
7764 check_equal (10.0, u, 100, &diff, &ulp);
7765 printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
7766 }
7767 #endif
7768
7769 int
7770 main (int argc, char **argv)
7771 {
7772
7773 int remaining;
7774
7775 verbose = 1;
7776 output_ulps = 0;
7777 output_max_error = 1;
7778 output_points = 1;
7779 /* XXX set to 0 for releases. */
7780 ignore_max_ulp = 0;
7781
7782 /* Parse and process arguments. */
7783 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
7784
7785 if (remaining != argc)
7786 {
7787 fprintf (stderr, "wrong number of arguments");
7788 argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
7789 exit (EXIT_FAILURE);
7790 }
7791
7792 if (output_ulps)
7793 {
7794 ulps_file = fopen ("ULPs", "a");
7795 if (ulps_file == NULL)
7796 {
7797 perror ("can't open file `ULPs' for writing: ");
7798 exit (1);
7799 }
7800 }
7801
7802
7803 initialize ();
7804 printf (TEST_MSG);
7805
7806 #if 0
7807 check_ulp ();
7808 #endif
7809
7810 /* Keep the tests a wee bit ordered (according to ISO C99). */
7811 /* Classification macros: */
7812 fpclassify_test ();
7813 isfinite_test ();
7814 isnormal_test ();
7815 signbit_test ();
7816
7817 /* Trigonometric functions: */
7818 acos_test ();
7819 asin_test ();
7820 atan_test ();
7821 atan2_test ();
7822 cos_test ();
7823 cos_test_tonearest ();
7824 cos_test_towardzero ();
7825 cos_test_downward ();
7826 cos_test_upward ();
7827 sin_test ();
7828 sin_test_tonearest ();
7829 sin_test_towardzero ();
7830 sin_test_downward ();
7831 sin_test_upward ();
7832 sincos_test ();
7833 tan_test ();
7834 tan_test_tonearest ();
7835 tan_test_towardzero ();
7836 tan_test_downward ();
7837 tan_test_upward ();
7838
7839 /* Hyperbolic functions: */
7840 acosh_test ();
7841 asinh_test ();
7842 atanh_test ();
7843 cosh_test ();
7844 cosh_test_tonearest ();
7845 cosh_test_towardzero ();
7846 cosh_test_downward ();
7847 cosh_test_upward ();
7848 sinh_test ();
7849 sinh_test_tonearest ();
7850 sinh_test_towardzero ();
7851 sinh_test_downward ();
7852 sinh_test_upward ();
7853 tanh_test ();
7854
7855 /* Exponential and logarithmic functions: */
7856 exp_test ();
7857 exp_test_tonearest ();
7858 exp_test_towardzero ();
7859 exp_test_downward ();
7860 exp_test_upward ();
7861 exp10_test ();
7862 exp2_test ();
7863 expm1_test ();
7864 frexp_test ();
7865 ldexp_test ();
7866 log_test ();
7867 log10_test ();
7868 log1p_test ();
7869 log2_test ();
7870 logb_test ();
7871 modf_test ();
7872 ilogb_test ();
7873 scalb_test ();
7874 scalbn_test ();
7875 scalbln_test ();
7876 significand_test ();
7877
7878 /* Power and absolute value functions: */
7879 cbrt_test ();
7880 fabs_test ();
7881 hypot_test ();
7882 pow_test ();
7883 pow_test_tonearest ();
7884 pow_test_towardzero ();
7885 pow_test_downward ();
7886 pow_test_upward ();
7887 sqrt_test ();
7888
7889 /* Error and gamma functions: */
7890 erf_test ();
7891 erfc_test ();
7892 gamma_test ();
7893 lgamma_test ();
7894 tgamma_test ();
7895
7896 /* Nearest integer functions: */
7897 ceil_test ();
7898 floor_test ();
7899 nearbyint_test ();
7900 rint_test ();
7901 rint_test_tonearest ();
7902 rint_test_towardzero ();
7903 rint_test_downward ();
7904 rint_test_upward ();
7905 lrint_test ();
7906 lrint_test_tonearest ();
7907 lrint_test_towardzero ();
7908 lrint_test_downward ();
7909 lrint_test_upward ();
7910 llrint_test ();
7911 llrint_test_tonearest ();
7912 llrint_test_towardzero ();
7913 llrint_test_downward ();
7914 llrint_test_upward ();
7915 round_test ();
7916 lround_test ();
7917 llround_test ();
7918 trunc_test ();
7919
7920 /* Remainder functions: */
7921 fmod_test ();
7922 remainder_test ();
7923 remquo_test ();
7924
7925 /* Manipulation functions: */
7926 copysign_test ();
7927 nextafter_test ();
7928 nexttoward_test ();
7929
7930 /* maximum, minimum and positive difference functions */
7931 fdim_test ();
7932 fmax_test ();
7933 fmin_test ();
7934
7935 /* Multiply and add: */
7936 fma_test ();
7937
7938 /* Complex functions: */
7939 cabs_test ();
7940 cacos_test ();
7941 cacosh_test ();
7942 carg_test ();
7943 casin_test ();
7944 casinh_test ();
7945 catan_test ();
7946 catanh_test ();
7947 ccos_test ();
7948 ccosh_test ();
7949 cexp_test ();
7950 cimag_test ();
7951 clog10_test ();
7952 clog_test ();
7953 conj_test ();
7954 cpow_test ();
7955 cproj_test ();
7956 creal_test ();
7957 csin_test ();
7958 csinh_test ();
7959 csqrt_test ();
7960 ctan_test ();
7961 ctanh_test ();
7962
7963 /* Bessel functions: */
7964 j0_test ();
7965 j1_test ();
7966 jn_test ();
7967 y0_test ();
7968 y1_test ();
7969 yn_test ();
7970
7971 if (output_ulps)
7972 fclose (ulps_file);
7973
7974 printf ("\nTest suite completed:\n");
7975 printf (" %d test cases plus %d tests for exception flags executed.\n",
7976 noTests, noExcTests);
7977 if (noXFails)
7978 printf (" %d expected failures occurred.\n", noXFails);
7979 if (noXPasses)
7980 printf (" %d unexpected passes occurred.\n", noXPasses);
7981 if (noErrors)
7982 {
7983 printf (" %d errors occurred.\n", noErrors);
7984 return 1;
7985 }
7986 printf (" All tests passed successfully.\n");
7987
7988 return 0;
7989 }
7990
7991 /*
7992 * Local Variables:
7993 * mode:c
7994 * End:
7995 */
A mirror of the official glibc repository