]> 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
[BZ #1950, BZ #2153]
[thirdparty/glibc.git] / math / libm-test.inc
1 /* Copyright (C) 1997-2002, 2003, 2004, 2005, 2006 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, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307 USA. */
19
20 /* Part of testsuite for libm.
21
22 This file is processed by a perl script. The resulting file has to
23 be included by a master file that defines:
24
25 Makros:
26 FUNC(function): converts general function name (like cos) to
27 name with correct suffix (e.g. cosl or cosf)
28 MATHCONST(x): like FUNC but for constants (e.g convert 0.0 to 0.0L)
29 FLOAT: floating point type to test
30 - TEST_MSG: informal message to be displayed
31 CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
32 chooses one of the parameters as delta for testing
33 equality
34 PRINTF_EXPR Floating point conversion specification to print a variable
35 of type FLOAT with printf. PRINTF_EXPR just contains
36 the specifier, not the percent and width arguments,
37 e.g. "f".
38 PRINTF_XEXPR Like PRINTF_EXPR, but print in hexadecimal format.
39 PRINTF_NEXPR Like PRINTF_EXPR, but print nice. */
40
41 /* This testsuite has currently tests for:
42 acos, acosh, asin, asinh, atan, atan2, atanh,
43 cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
44 fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
45 frexp, gamma, hypot,
46 ilogb, isfinite, isinf, isnan, isnormal,
47 isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
48 j0, j1, jn,
49 ldexp, lgamma, log, log10, log1p, log2, logb,
50 modf, nearbyint, nextafter,
51 pow, remainder, remquo, rint, lrint, llrint,
52 round, lround, llround,
53 scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
54 y0, y1, yn, significand
55
56 and for the following complex math functions:
57 cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
58 ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.
59
60 At the moment the following functions aren't tested:
61 drem, nan
62
63 Parameter handling is primitive in the moment:
64 --verbose=[0..3] for different levels of output:
65 0: only error count
66 1: basic report on failed tests (default)
67 2: full report on all tests
68 -v for full output (equals --verbose=3)
69 -u for generation of an ULPs file
70 */
71
72 /* "Philosophy":
73
74 This suite tests some aspects of the correct implementation of
75 mathematical functions in libm. Some simple, specific parameters
76 are tested for correctness but there's no exhaustive
77 testing. Handling of specific inputs (e.g. infinity, not-a-number)
78 is also tested. Correct handling of exceptions is checked
79 against. These implemented tests should check all cases that are
80 specified in ISO C99.
81
82 Exception testing: At the moment only divide-by-zero and invalid
83 exceptions are tested. Overflow/underflow and inexact exceptions
84 aren't checked at the moment.
85
86 NaN values: There exist signalling and quiet NaNs. This implementation
87 only uses quiet NaN as parameter but does not differenciate
88 between the two kinds of NaNs as result.
89
90 Inline functions: Inlining functions should give an improvement in
91 speed - but not in precission. The inlined functions return
92 reasonable values for a reasonable range of input values. The
93 result is not necessarily correct for all values and exceptions are
94 not correctly raised in all cases. Problematic input and return
95 values are infinity, not-a-number and minus zero. This suite
96 therefore does not check these specific inputs and the exception
97 handling for inlined mathematical functions - just the "reasonable"
98 values are checked.
99
100 Beware: The tests might fail for any of the following reasons:
101 - Tests are wrong
102 - Functions are wrong
103 - Floating Point Unit not working properly
104 - Compiler has errors
105
106 With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
107
108
109 To Do: All parameter should be numbers that can be represented as
110 exact floating point values. Currently some values cannot be
111 represented exactly and therefore the result is not the expected
112 result. For this we will use 36 digits so that numbers can be
113 represented exactly. */
114
115 #ifndef _GNU_SOURCE
116 # define _GNU_SOURCE
117 #endif
118
119 #include "libm-test-ulps.h"
120 #include <complex.h>
121 #include <math.h>
122 #include <float.h>
123 #include <fenv.h>
124 #include <limits.h>
125
126 #include <errno.h>
127 #include <stdlib.h>
128 #include <stdio.h>
129 #include <string.h>
130 #include <argp.h>
131
132 /* Possible exceptions */
133 #define NO_EXCEPTION 0x0
134 #define INVALID_EXCEPTION 0x1
135 #define DIVIDE_BY_ZERO_EXCEPTION 0x2
136 /* The next flags signals that those exceptions are allowed but not required. */
137 #define INVALID_EXCEPTION_OK 0x4
138 #define DIVIDE_BY_ZERO_EXCEPTION_OK 0x8
139 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
140 /* Some special test flags, passed togther with exceptions. */
141 #define IGNORE_ZERO_INF_SIGN 0x10
142
143 /* Various constants (we must supply them precalculated for accuracy). */
144 #define M_PI_6l .52359877559829887307710723054658383L
145 #define M_E2l 7.389056098930650227230427460575008L
146 #define M_E3l 20.085536923187667740928529654581719L
147 #define M_2_SQRT_PIl 3.5449077018110320545963349666822903L /* 2 sqrt (M_PIl) */
148 #define M_SQRT_PIl 1.7724538509055160272981674833411451L /* sqrt (M_PIl) */
149 #define M_LOG_SQRT_PIl 0.57236494292470008707171367567652933L /* log(sqrt(M_PIl)) */
150 #define M_LOG_2_SQRT_PIl 1.265512123484645396488945797134706L /* log(2*sqrt(M_PIl)) */
151 #define M_PI_34l (M_PIl - M_PI_4l) /* 3*pi/4 */
152 #define M_PI_34_LOG10El (M_PIl - M_PI_4l) * M_LOG10El
153 #define M_PI2_LOG10El M_PI_2l * M_LOG10El
154 #define M_PI4_LOG10El M_PI_4l * M_LOG10El
155 #define M_PI_LOG10El M_PIl * M_LOG10El
156 #define M_SQRT_2_2 0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
157
158 static FILE *ulps_file; /* File to document difference. */
159 static int output_ulps; /* Should ulps printed? */
160
161 static int noErrors; /* number of errors */
162 static int noTests; /* number of tests (without testing exceptions) */
163 static int noExcTests; /* number of tests for exception flags */
164 static int noXFails; /* number of expected failures. */
165 static int noXPasses; /* number of unexpected passes. */
166
167 static int verbose;
168 static int output_max_error; /* Should the maximal errors printed? */
169 static int output_points; /* Should the single function results printed? */
170 static int ignore_max_ulp; /* Should we ignore max_ulp? */
171
172 static FLOAT minus_zero, plus_zero;
173 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
174
175 static FLOAT max_error, real_max_error, imag_max_error;
176
177
178 #define BUILD_COMPLEX(real, imag) \
179 ({ __complex__ FLOAT __retval; \
180 __real__ __retval = (real); \
181 __imag__ __retval = (imag); \
182 __retval; })
183
184 #define BUILD_COMPLEX_INT(real, imag) \
185 ({ __complex__ int __retval; \
186 __real__ __retval = (real); \
187 __imag__ __retval = (imag); \
188 __retval; })
189
190
191 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1), \
192 (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
193
194 static void
195 init_max_error (void)
196 {
197 max_error = 0;
198 real_max_error = 0;
199 imag_max_error = 0;
200 feclearexcept (FE_ALL_EXCEPT);
201 }
202
203 static void
204 set_max_error (FLOAT current, FLOAT *curr_max_error)
205 {
206 if (current > *curr_max_error)
207 *curr_max_error = current;
208 }
209
210
211 /* Should the message print to screen? This depends on the verbose flag,
212 and the test status. */
213 static int
214 print_screen (int ok, int xfail)
215 {
216 if (output_points
217 && (verbose > 1
218 || (verbose == 1 && ok == xfail)))
219 return 1;
220 return 0;
221 }
222
223
224 /* Should the message print to screen? This depends on the verbose flag,
225 and the test status. */
226 static int
227 print_screen_max_error (int ok, int xfail)
228 {
229 if (output_max_error
230 && (verbose > 1
231 || ((verbose == 1) && (ok == xfail))))
232 return 1;
233 return 0;
234 }
235
236 /* Update statistic counters. */
237 static void
238 update_stats (int ok, int xfail)
239 {
240 ++noTests;
241 if (ok && xfail)
242 ++noXPasses;
243 else if (!ok && xfail)
244 ++noXFails;
245 else if (!ok && !xfail)
246 ++noErrors;
247 }
248
249 static void
250 print_ulps (const char *test_name, FLOAT ulp)
251 {
252 if (output_ulps)
253 {
254 fprintf (ulps_file, "Test \"%s\":\n", test_name);
255 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
256 CHOOSE("ldouble", "double", "float",
257 "ildouble", "idouble", "ifloat"),
258 FUNC(ceil) (ulp));
259 }
260 }
261
262 static void
263 print_function_ulps (const char *function_name, FLOAT ulp)
264 {
265 if (output_ulps)
266 {
267 fprintf (ulps_file, "Function: \"%s\":\n", function_name);
268 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
269 CHOOSE("ldouble", "double", "float",
270 "ildouble", "idouble", "ifloat"),
271 FUNC(ceil) (ulp));
272 }
273 }
274
275
276 static void
277 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
278 FLOAT imag_ulp)
279 {
280 if (output_ulps)
281 {
282 if (real_ulp != 0.0)
283 {
284 fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
285 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
286 CHOOSE("ldouble", "double", "float",
287 "ildouble", "idouble", "ifloat"),
288 FUNC(ceil) (real_ulp));
289 }
290 if (imag_ulp != 0.0)
291 {
292 fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
293 fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
294 CHOOSE("ldouble", "double", "float",
295 "ildouble", "idouble", "ifloat"),
296 FUNC(ceil) (imag_ulp));
297 }
298
299
300 }
301 }
302
303
304
305 /* Test if Floating-Point stack hasn't changed */
306 static void
307 fpstack_test (const char *test_name)
308 {
309 #ifdef i386
310 static int old_stack;
311 int sw;
312
313 asm ("fnstsw" : "=a" (sw));
314 sw >>= 11;
315 sw &= 7;
316
317 if (sw != old_stack)
318 {
319 printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
320 test_name, sw, old_stack);
321 ++noErrors;
322 old_stack = sw;
323 }
324 #endif
325 }
326
327
328 static void
329 print_max_error (const char *func_name, FLOAT allowed, int xfail)
330 {
331 int ok = 0;
332
333 if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
334 {
335 ok = 1;
336 }
337
338 if (!ok)
339 print_function_ulps (func_name, max_error);
340
341
342 if (print_screen_max_error (ok, xfail))
343 {
344 printf ("Maximal error of `%s'\n", func_name);
345 printf (" is : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
346 printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
347 }
348
349 update_stats (ok, xfail);
350 }
351
352
353 static void
354 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
355 __complex__ int xfail)
356 {
357 int ok = 0;
358
359 if ((real_max_error == 0 && imag_max_error == 0)
360 || (real_max_error <= __real__ allowed
361 && imag_max_error <= __imag__ allowed
362 && !ignore_max_ulp))
363 {
364 ok = 1;
365 }
366
367 if (!ok)
368 print_complex_function_ulps (func_name, real_max_error, imag_max_error);
369
370
371 if (print_screen_max_error (ok, xfail))
372 {
373 printf ("Maximal error of real part of: %s\n", func_name);
374 printf (" is : %.0" PRINTF_NEXPR " ulp\n",
375 FUNC(ceil) (real_max_error));
376 printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
377 FUNC(ceil) (__real__ allowed));
378 printf ("Maximal error of imaginary part of: %s\n", func_name);
379 printf (" is : %.0" PRINTF_NEXPR " ulp\n",
380 FUNC(ceil) (imag_max_error));
381 printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
382 FUNC(ceil) (__imag__ allowed));
383 }
384
385 update_stats (ok, xfail);
386 }
387
388
389 /* Test whether a given exception was raised. */
390 static void
391 test_single_exception (const char *test_name,
392 int exception,
393 int exc_flag,
394 int fe_flag,
395 const char *flag_name)
396 {
397 #ifndef TEST_INLINE
398 int ok = 1;
399 if (exception & exc_flag)
400 {
401 if (fetestexcept (fe_flag))
402 {
403 if (print_screen (1, 0))
404 printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
405 }
406 else
407 {
408 ok = 0;
409 if (print_screen (0, 0))
410 printf ("Failure: %s: Exception \"%s\" not set\n",
411 test_name, flag_name);
412 }
413 }
414 else
415 {
416 if (fetestexcept (fe_flag))
417 {
418 ok = 0;
419 if (print_screen (0, 0))
420 printf ("Failure: %s: Exception \"%s\" set\n",
421 test_name, flag_name);
422 }
423 else
424 {
425 if (print_screen (1, 0))
426 printf ("%s: Exception \"%s\" not set\n", test_name,
427 flag_name);
428 }
429 }
430 if (!ok)
431 ++noErrors;
432
433 #endif
434 }
435
436
437 /* Test whether exceptions given by EXCEPTION are raised. Ignore thereby
438 allowed but not required exceptions.
439 */
440 static void
441 test_exceptions (const char *test_name, int exception)
442 {
443 ++noExcTests;
444 #ifdef FE_DIVBYZERO
445 if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
446 test_single_exception (test_name, exception,
447 DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
448 "Divide by zero");
449 #endif
450 #ifdef FE_INVALID
451 if ((exception & INVALID_EXCEPTION_OK) == 0)
452 test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
453 "Invalid operation");
454 #endif
455 feclearexcept (FE_ALL_EXCEPT);
456 }
457
458
459 static void
460 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
461 FLOAT max_ulp, int xfail, int exceptions,
462 FLOAT *curr_max_error)
463 {
464 int ok = 0;
465 int print_diff = 0;
466 FLOAT diff = 0;
467 FLOAT ulp = 0;
468
469 test_exceptions (test_name, exceptions);
470 if (isnan (computed) && isnan (expected))
471 ok = 1;
472 else if (isinf (computed) && isinf (expected))
473 {
474 /* Test for sign of infinities. */
475 if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
476 && signbit (computed) != signbit (expected))
477 {
478 ok = 0;
479 printf ("infinity has wrong sign.\n");
480 }
481 else
482 ok = 1;
483 }
484 /* Don't calc ulp for NaNs or infinities. */
485 else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
486 ok = 0;
487 else
488 {
489 diff = FUNC(fabs) (computed - expected);
490 /* ilogb (0) isn't allowed. */
491 if (expected == 0.0)
492 ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
493 else
494 ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
495 set_max_error (ulp, curr_max_error);
496 print_diff = 1;
497 if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
498 && computed == 0.0 && expected == 0.0
499 && signbit(computed) != signbit (expected))
500 ok = 0;
501 else if (ulp == 0.0 || (ulp <= max_ulp && !ignore_max_ulp))
502 ok = 1;
503 else
504 {
505 ok = 0;
506 print_ulps (test_name, ulp);
507 }
508
509 }
510 if (print_screen (ok, xfail))
511 {
512 if (!ok)
513 printf ("Failure: ");
514 printf ("Test: %s\n", test_name);
515 printf ("Result:\n");
516 printf (" is: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n",
517 computed, computed);
518 printf (" should be: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n",
519 expected, expected);
520 if (print_diff)
521 {
522 printf (" difference: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR
523 "\n", diff, diff);
524 printf (" ulp : % .4" PRINTF_NEXPR "\n", ulp);
525 printf (" max.ulp : % .4" PRINTF_NEXPR "\n", max_ulp);
526 }
527 }
528 update_stats (ok, xfail);
529
530 fpstack_test (test_name);
531 }
532
533
534 static void
535 check_float (const char *test_name, FLOAT computed, FLOAT expected,
536 FLOAT max_ulp, int xfail, int exceptions)
537 {
538 check_float_internal (test_name, computed, expected, max_ulp, xfail,
539 exceptions, &max_error);
540 }
541
542
543 static void
544 check_complex (const char *test_name, __complex__ FLOAT computed,
545 __complex__ FLOAT expected,
546 __complex__ FLOAT max_ulp, __complex__ int xfail,
547 int exception)
548 {
549 FLOAT part_comp, part_exp, part_max_ulp;
550 int part_xfail;
551 char str[200];
552
553 sprintf (str, "Real part of: %s", test_name);
554 part_comp = __real__ computed;
555 part_exp = __real__ expected;
556 part_max_ulp = __real__ max_ulp;
557 part_xfail = __real__ xfail;
558
559 check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
560 exception, &real_max_error);
561
562 sprintf (str, "Imaginary part of: %s", test_name);
563 part_comp = __imag__ computed;
564 part_exp = __imag__ expected;
565 part_max_ulp = __imag__ max_ulp;
566 part_xfail = __imag__ xfail;
567
568 /* Don't check again for exceptions, just pass through the
569 zero/inf sign test. */
570 check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
571 exception & IGNORE_ZERO_INF_SIGN,
572 &imag_max_error);
573 }
574
575
576 /* Check that computed and expected values are equal (int values). */
577 static void
578 check_int (const char *test_name, int computed, int expected, int max_ulp,
579 int xfail, int exceptions)
580 {
581 int diff = computed - expected;
582 int ok = 0;
583
584 test_exceptions (test_name, exceptions);
585 noTests++;
586 if (abs (diff) <= max_ulp)
587 ok = 1;
588
589 if (!ok)
590 print_ulps (test_name, diff);
591
592 if (print_screen (ok, xfail))
593 {
594 if (!ok)
595 printf ("Failure: ");
596 printf ("Test: %s\n", test_name);
597 printf ("Result:\n");
598 printf (" is: %d\n", computed);
599 printf (" should be: %d\n", expected);
600 }
601
602 update_stats (ok, xfail);
603 fpstack_test (test_name);
604 }
605
606
607 /* Check that computed and expected values are equal (long int values). */
608 static void
609 check_long (const char *test_name, long int computed, long int expected,
610 long int max_ulp, int xfail, int exceptions)
611 {
612 long int diff = computed - expected;
613 int ok = 0;
614
615 test_exceptions (test_name, exceptions);
616 noTests++;
617 if (labs (diff) <= max_ulp)
618 ok = 1;
619
620 if (!ok)
621 print_ulps (test_name, diff);
622
623 if (print_screen (ok, xfail))
624 {
625 if (!ok)
626 printf ("Failure: ");
627 printf ("Test: %s\n", test_name);
628 printf ("Result:\n");
629 printf (" is: %ld\n", computed);
630 printf (" should be: %ld\n", expected);
631 }
632
633 update_stats (ok, xfail);
634 fpstack_test (test_name);
635 }
636
637
638 /* Check that computed value is true/false. */
639 static void
640 check_bool (const char *test_name, int computed, int expected,
641 long int max_ulp, int xfail, int exceptions)
642 {
643 int ok = 0;
644
645 test_exceptions (test_name, exceptions);
646 noTests++;
647 if ((computed == 0) == (expected == 0))
648 ok = 1;
649
650 if (print_screen (ok, xfail))
651 {
652 if (!ok)
653 printf ("Failure: ");
654 printf ("Test: %s\n", test_name);
655 printf ("Result:\n");
656 printf (" is: %d\n", computed);
657 printf (" should be: %d\n", expected);
658 }
659
660 update_stats (ok, xfail);
661 fpstack_test (test_name);
662 }
663
664
665 /* check that computed and expected values are equal (long int values) */
666 static void
667 check_longlong (const char *test_name, long long int computed,
668 long long int expected,
669 long long int max_ulp, int xfail,
670 int exceptions)
671 {
672 long long int diff = computed - expected;
673 int ok = 0;
674
675 test_exceptions (test_name, exceptions);
676 noTests++;
677 if (llabs (diff) <= max_ulp)
678 ok = 1;
679
680 if (!ok)
681 print_ulps (test_name, diff);
682
683 if (print_screen (ok, xfail))
684 {
685 if (!ok)
686 printf ("Failure:");
687 printf ("Test: %s\n", test_name);
688 printf ("Result:\n");
689 printf (" is: %lld\n", computed);
690 printf (" should be: %lld\n", expected);
691 }
692
693 update_stats (ok, xfail);
694 fpstack_test (test_name);
695 }
696
697
698
699 /* This is to prevent messages from the SVID libm emulation. */
700 int
701 matherr (struct exception *x __attribute__ ((unused)))
702 {
703 return 1;
704 }
705
706
707 /****************************************************************************
708 Tests for single functions of libm.
709 Please keep them alphabetically sorted!
710 ****************************************************************************/
711
712 static void
713 acos_test (void)
714 {
715 errno = 0;
716 FUNC(acos) (0);
717 if (errno == ENOSYS)
718 /* Function not implemented. */
719 return;
720
721 START (acos);
722
723 TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
724 TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
725 TEST_f_f (acos, nan_value, nan_value);
726
727 /* |x| > 1: */
728 TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
729 TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
730
731 TEST_f_f (acos, 0, M_PI_2l);
732 TEST_f_f (acos, minus_zero, M_PI_2l);
733 TEST_f_f (acos, 1, 0);
734 TEST_f_f (acos, -1, M_PIl);
735 TEST_f_f (acos, 0.5, M_PI_6l*2.0);
736 TEST_f_f (acos, -0.5, M_PI_6l*4.0);
737 TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
738 TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
739 TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
740 END (acos);
741 }
742
743 static void
744 acosh_test (void)
745 {
746 errno = 0;
747 FUNC(acosh) (7);
748 if (errno == ENOSYS)
749 /* Function not implemented. */
750 return;
751
752 START (acosh);
753
754 TEST_f_f (acosh, plus_infty, plus_infty);
755 TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
756
757 /* x < 1: */
758 TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
759
760 TEST_f_f (acosh, 1, 0);
761 TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
762
763 END (acosh);
764 }
765
766 static void
767 asin_test (void)
768 {
769 errno = 0;
770 FUNC(asin) (0);
771 if (errno == ENOSYS)
772 /* Function not implemented. */
773 return;
774
775 START (asin);
776
777 TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
778 TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
779 TEST_f_f (asin, nan_value, nan_value);
780
781 /* asin x == NaN plus invalid exception for |x| > 1. */
782 TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
783 TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
784
785 TEST_f_f (asin, 0, 0);
786 TEST_f_f (asin, minus_zero, minus_zero);
787 TEST_f_f (asin, 0.5, M_PI_6l);
788 TEST_f_f (asin, -0.5, -M_PI_6l);
789 TEST_f_f (asin, 1.0, M_PI_2l);
790 TEST_f_f (asin, -1.0, -M_PI_2l);
791 TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
792
793 END (asin);
794 }
795
796 static void
797 asinh_test (void)
798 {
799 errno = 0;
800 FUNC(asinh) (0.7L);
801 if (errno == ENOSYS)
802 /* Function not implemented. */
803 return;
804
805 START (asinh);
806
807 TEST_f_f (asinh, 0, 0);
808 TEST_f_f (asinh, minus_zero, minus_zero);
809 #ifndef TEST_INLINE
810 TEST_f_f (asinh, plus_infty, plus_infty);
811 TEST_f_f (asinh, minus_infty, minus_infty);
812 #endif
813 TEST_f_f (asinh, nan_value, nan_value);
814 TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
815
816 END (asinh);
817 }
818
819 static void
820 atan_test (void)
821 {
822 errno = 0;
823 FUNC(atan) (0);
824 if (errno == ENOSYS)
825 /* Function not implemented. */
826 return;
827
828 START (atan);
829
830 TEST_f_f (atan, 0, 0);
831 TEST_f_f (atan, minus_zero, minus_zero);
832
833 TEST_f_f (atan, plus_infty, M_PI_2l);
834 TEST_f_f (atan, minus_infty, -M_PI_2l);
835 TEST_f_f (atan, nan_value, nan_value);
836
837 TEST_f_f (atan, 1, M_PI_4l);
838 TEST_f_f (atan, -1, -M_PI_4l);
839
840 TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
841
842 END (atan);
843 }
844
845
846
847 static void
848 atanh_test (void)
849 {
850 errno = 0;
851 FUNC(atanh) (0.7L);
852 if (errno == ENOSYS)
853 /* Function not implemented. */
854 return;
855
856 START (atanh);
857
858
859 TEST_f_f (atanh, 0, 0);
860 TEST_f_f (atanh, minus_zero, minus_zero);
861
862 TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
863 TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
864 TEST_f_f (atanh, nan_value, nan_value);
865
866 /* atanh (x) == NaN plus invalid exception if |x| > 1. */
867 TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
868 TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
869
870 TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
871
872 END (atanh);
873 }
874
875 static void
876 atan2_test (void)
877 {
878 errno = 0;
879 FUNC(atan2) (-0, 1);
880 if (errno == ENOSYS)
881 /* Function not implemented. */
882 return;
883
884 START (atan2);
885
886 /* atan2 (0,x) == 0 for x > 0. */
887 TEST_ff_f (atan2, 0, 1, 0);
888
889 /* atan2 (-0,x) == -0 for x > 0. */
890 TEST_ff_f (atan2, minus_zero, 1, minus_zero);
891
892 TEST_ff_f (atan2, 0, 0, 0);
893 TEST_ff_f (atan2, minus_zero, 0, minus_zero);
894
895 /* atan2 (+0,x) == +pi for x < 0. */
896 TEST_ff_f (atan2, 0, -1, M_PIl);
897
898 /* atan2 (-0,x) == -pi for x < 0. */
899 TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
900
901 TEST_ff_f (atan2, 0, minus_zero, M_PIl);
902 TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
903
904 /* atan2 (y,+0) == pi/2 for y > 0. */
905 TEST_ff_f (atan2, 1, 0, M_PI_2l);
906
907 /* atan2 (y,-0) == pi/2 for y > 0. */
908 TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
909
910 /* atan2 (y,+0) == -pi/2 for y < 0. */
911 TEST_ff_f (atan2, -1, 0, -M_PI_2l);
912
913 /* atan2 (y,-0) == -pi/2 for y < 0. */
914 TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
915
916 /* atan2 (y,inf) == +0 for finite y > 0. */
917 TEST_ff_f (atan2, 1, plus_infty, 0);
918
919 /* atan2 (y,inf) == -0 for finite y < 0. */
920 TEST_ff_f (atan2, -1, plus_infty, minus_zero);
921
922 /* atan2(+inf, x) == pi/2 for finite x. */
923 TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
924
925 /* atan2(-inf, x) == -pi/2 for finite x. */
926 TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
927
928 /* atan2 (y,-inf) == +pi for finite y > 0. */
929 TEST_ff_f (atan2, 1, minus_infty, M_PIl);
930
931 /* atan2 (y,-inf) == -pi for finite y < 0. */
932 TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
933
934 TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
935 TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
936 TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
937 TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
938 TEST_ff_f (atan2, nan_value, nan_value, nan_value);
939
940 TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
941 TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
942 TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
943 TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
944 TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
945 TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
946
947 TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
948
949 END (atan2);
950 }
951
952 static void
953 cabs_test (void)
954 {
955 errno = 0;
956 FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
957 if (errno == ENOSYS)
958 /* Function not implemented. */
959 return;
960
961 START (cabs);
962
963 /* cabs (x + iy) is specified as hypot (x,y) */
964
965 /* cabs (+inf + i x) == +inf. */
966 TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
967 /* cabs (-inf + i x) == +inf. */
968 TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
969
970 TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
971 TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
972
973 TEST_c_f (cabs, nan_value, nan_value, nan_value);
974
975 /* cabs (x,y) == cabs (y,x). */
976 TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
977 /* cabs (x,y) == cabs (-x,y). */
978 TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
979 /* cabs (x,y) == cabs (-y,x). */
980 TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
981 /* cabs (x,y) == cabs (-x,-y). */
982 TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
983 /* cabs (x,y) == cabs (-y,-x). */
984 TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
985 /* cabs (x,0) == fabs (x). */
986 TEST_c_f (cabs, -0.75L, 0, 0.75L);
987 TEST_c_f (cabs, 0.75L, 0, 0.75L);
988 TEST_c_f (cabs, -1.0L, 0, 1.0L);
989 TEST_c_f (cabs, 1.0L, 0, 1.0L);
990 TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
991 TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
992
993 TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
994
995 END (cabs);
996 }
997
998
999 static void
1000 cacos_test (void)
1001 {
1002 errno = 0;
1003 FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1004 if (errno == ENOSYS)
1005 /* Function not implemented. */
1006 return;
1007
1008 START (cacos);
1009
1010
1011 TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1012 TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1013 TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1014 TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1015
1016 TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1017 TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1018
1019 TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1020 TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1021
1022 TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1023 TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1024 TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1025 TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1026 TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1027 TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1028
1029 TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1030 TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1031 TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1032 TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1033
1034 TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1035 TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1036 TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1037 TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1038
1039 TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1040 TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1041
1042 TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1043 TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1044
1045 TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1046 TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1047
1048 TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1049 TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1050
1051 TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1052 TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1053
1054 TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1055
1056 TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1057 TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1058
1059 END (cacos, complex);
1060 }
1061
1062 static void
1063 cacosh_test (void)
1064 {
1065 errno = 0;
1066 FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1067 if (errno == ENOSYS)
1068 /* Function not implemented. */
1069 return;
1070
1071 START (cacosh);
1072
1073
1074 TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1075 TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1076 TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1077 TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1078 TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1079 TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1080
1081 TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1082 TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1083
1084 TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1085 TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1086 TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1087 TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1088 TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1089 TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1090
1091 TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1092 TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1093 TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1094 TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1095
1096 TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1097 TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1098 TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1099 TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1100
1101 TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1102 TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1103
1104 TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1105 TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1106
1107 TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1108 TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1109
1110 TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1111 TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1112
1113 TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1114 TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1115
1116 TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1117
1118 TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1119 TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1120
1121 END (cacosh, complex);
1122 }
1123
1124
1125 static void
1126 carg_test (void)
1127 {
1128 START (carg);
1129
1130 /* carg (x + iy) is specified as atan2 (y, x) */
1131
1132 /* carg (x + i 0) == 0 for x > 0. */
1133 TEST_c_f (carg, 2.0, 0, 0);
1134 /* carg (x - i 0) == -0 for x > 0. */
1135 TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1136
1137 TEST_c_f (carg, 0, 0, 0);
1138 TEST_c_f (carg, 0, minus_zero, minus_zero);
1139
1140 /* carg (x + i 0) == +pi for x < 0. */
1141 TEST_c_f (carg, -2.0, 0, M_PIl);
1142
1143 /* carg (x - i 0) == -pi for x < 0. */
1144 TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1145
1146 TEST_c_f (carg, minus_zero, 0, M_PIl);
1147 TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1148
1149 /* carg (+0 + i y) == pi/2 for y > 0. */
1150 TEST_c_f (carg, 0, 2.0, M_PI_2l);
1151
1152 /* carg (-0 + i y) == pi/2 for y > 0. */
1153 TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1154
1155 /* carg (+0 + i y) == -pi/2 for y < 0. */
1156 TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1157
1158 /* carg (-0 + i y) == -pi/2 for y < 0. */
1159 TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1160
1161 /* carg (inf + i y) == +0 for finite y > 0. */
1162 TEST_c_f (carg, plus_infty, 2.0, 0);
1163
1164 /* carg (inf + i y) == -0 for finite y < 0. */
1165 TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1166
1167 /* carg(x + i inf) == pi/2 for finite x. */
1168 TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1169
1170 /* carg(x - i inf) == -pi/2 for finite x. */
1171 TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1172
1173 /* carg (-inf + i y) == +pi for finite y > 0. */
1174 TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1175
1176 /* carg (-inf + i y) == -pi for finite y < 0. */
1177 TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1178
1179 TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1180
1181 TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1182
1183 TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1184
1185 TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1186
1187 TEST_c_f (carg, nan_value, nan_value, nan_value);
1188
1189 END (carg);
1190 }
1191
1192 static void
1193 casin_test (void)
1194 {
1195 errno = 0;
1196 FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1197 if (errno == ENOSYS)
1198 /* Function not implemented. */
1199 return;
1200
1201 START (casin);
1202
1203 TEST_c_c (casin, 0, 0, 0.0, 0.0);
1204 TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1205 TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1206 TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1207
1208 TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1209 TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1210 TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1211 TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1212
1213 TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1214 TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1215 TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1216 TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1217 TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1218 TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1219 TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1220 TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1221
1222 TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1223 TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1224 TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1225 TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1226
1227 TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1228 TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1229 TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1230 TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1231
1232 TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1233 TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1234
1235 TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1236 TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1237
1238 TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1239 TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1240
1241 TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1242 TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1243
1244 TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1245 TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1246
1247 TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1248
1249 TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1250 TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1251
1252 END (casin, complex);
1253 }
1254
1255
1256 static void
1257 casinh_test (void)
1258 {
1259 errno = 0;
1260 FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1261 if (errno == ENOSYS)
1262 /* Function not implemented. */
1263 return;
1264
1265 START (casinh);
1266
1267 TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1268 TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1269 TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1270 TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1271
1272 TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1273 TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1274 TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1275 TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1276
1277 TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1278 TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1279 TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1280 TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1281 TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1282 TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1283 TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1284 TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1285
1286 TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1287 TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1288 TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1289 TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1290
1291 TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1292 TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1293 TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1294 TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1295
1296 TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1297 TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1298
1299 TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1300 TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1301
1302 TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1303 TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1304
1305 TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1306 TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1307
1308 TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1309 TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1310
1311 TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1312
1313 TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1314 TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1315
1316 END (casinh, complex);
1317 }
1318
1319
1320 static void
1321 catan_test (void)
1322 {
1323 errno = 0;
1324 FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1325 if (errno == ENOSYS)
1326 /* Function not implemented. */
1327 return;
1328
1329 START (catan);
1330
1331 TEST_c_c (catan, 0, 0, 0, 0);
1332 TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1333 TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1334 TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1335
1336 TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1337 TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1338 TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1339 TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1340
1341
1342 TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1343 TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1344 TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1345 TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1346 TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1347 TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1348 TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1349 TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1350
1351 TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1352 TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1353 TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1354 TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1355
1356 TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1357 TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1358 TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1359 TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1360
1361 TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1362 TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1363
1364 TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1365 TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1366
1367 TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1368 TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1369
1370 TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1371 TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1372
1373 TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1374 TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1375
1376 TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1377 TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1378
1379 TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1380
1381 TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1382 TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1383
1384 END (catan, complex);
1385 }
1386
1387 static void
1388 catanh_test (void)
1389 {
1390 errno = 0;
1391 FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1392 if (errno == ENOSYS)
1393 /* Function not implemented. */
1394 return;
1395
1396 START (catanh);
1397
1398 TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1399 TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1400 TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1401 TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1402
1403 TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1404 TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1405 TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1406 TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1407
1408 TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1409 TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1410 TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1411 TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1412 TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1413 TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1414 TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1415 TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1416
1417 TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1418 TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1419 TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1420 TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1421
1422 TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1423 TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1424 TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1425 TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1426
1427 TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1428 TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1429
1430 TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1431 TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1432
1433 TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1434 TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1435
1436 TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1437 TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1438
1439 TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1440 TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1441
1442 TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1443 TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1444
1445 TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1446
1447 TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1448 TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1449
1450 END (catanh, complex);
1451 }
1452
1453 static void
1454 cbrt_test (void)
1455 {
1456 errno = 0;
1457 FUNC(cbrt) (8);
1458 if (errno == ENOSYS)
1459 /* Function not implemented. */
1460 return;
1461
1462 START (cbrt);
1463
1464 TEST_f_f (cbrt, 0.0, 0.0);
1465 TEST_f_f (cbrt, minus_zero, minus_zero);
1466
1467 TEST_f_f (cbrt, plus_infty, plus_infty);
1468 TEST_f_f (cbrt, minus_infty, minus_infty);
1469 TEST_f_f (cbrt, nan_value, nan_value);
1470
1471 TEST_f_f (cbrt, -0.001L, -0.1L);
1472 TEST_f_f (cbrt, 8, 2);
1473 TEST_f_f (cbrt, -27.0, -3.0);
1474 TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1475 TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1476
1477 END (cbrt);
1478 }
1479
1480
1481 static void
1482 ccos_test (void)
1483 {
1484 errno = 0;
1485 FUNC(ccos) (BUILD_COMPLEX (0, 0));
1486 if (errno == ENOSYS)
1487 /* Function not implemented. */
1488 return;
1489
1490 START (ccos);
1491
1492 TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1493 TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1494 TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1495 TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1496
1497 TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1498 TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1499 TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1500 TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1501
1502 TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1503 TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1504 TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1505 TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1506
1507 TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1508 TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1509 TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1510 TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1511
1512 TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1513 TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1514 TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1515 TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1516
1517 TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1518 TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1519 TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1520 TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1521
1522 TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1523 TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1524
1525 TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1526 TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1527
1528 TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1529 TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1530
1531 TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1532 TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1533
1534 TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1535 TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1536
1537 TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1538 TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1539
1540 TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1541
1542 TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1543 TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1544
1545 END (ccos, complex);
1546 }
1547
1548
1549 static void
1550 ccosh_test (void)
1551 {
1552 errno = 0;
1553 FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
1554 if (errno == ENOSYS)
1555 /* Function not implemented. */
1556 return;
1557
1558 START (ccosh);
1559
1560 TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1561 TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1562 TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1563 TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1564
1565 TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1566 TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1567 TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1568 TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1569
1570 TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1571 TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1572 TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1573 TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1574
1575 TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1576 TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1577 TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1578 TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1579
1580 TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1581 TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1582 TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1583 TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1584
1585 TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1586 TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1587 TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1588 TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1589
1590 TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1591 TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1592
1593 TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1594 TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1595
1596 TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1597 TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1598
1599 TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1600 TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1601
1602 TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1603 TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1604
1605 TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1606 TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1607
1608 TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1609
1610 TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
1611
1612 TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
1613
1614 END (ccosh, complex);
1615 }
1616
1617
1618 static void
1619 ceil_test (void)
1620 {
1621 START (ceil);
1622
1623 TEST_f_f (ceil, 0.0, 0.0);
1624 TEST_f_f (ceil, minus_zero, minus_zero);
1625 TEST_f_f (ceil, plus_infty, plus_infty);
1626 TEST_f_f (ceil, minus_infty, minus_infty);
1627 TEST_f_f (ceil, nan_value, nan_value);
1628
1629 TEST_f_f (ceil, M_PIl, 4.0);
1630 TEST_f_f (ceil, -M_PIl, -3.0);
1631 TEST_f_f (ceil, 0.25, 1.0);
1632 TEST_f_f (ceil, -0.25, minus_zero);
1633
1634 END (ceil);
1635 }
1636
1637
1638 static void
1639 cexp_test (void)
1640 {
1641 errno = 0;
1642 FUNC(cexp) (BUILD_COMPLEX (0, 0));
1643 if (errno == ENOSYS)
1644 /* Function not implemented. */
1645 return;
1646
1647 START (cexp);
1648
1649 TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1650 TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1651 TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1652 TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1653
1654 TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1655 TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1656
1657 TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1658 TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1659
1660 TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1661 TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1662
1663 TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1664 TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1665
1666 TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1667 TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1668
1669 TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1670 TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1671
1672 TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1673 TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1674 TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1675 TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1676
1677 TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1678 TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1679
1680 TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1681 TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1682
1683 TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1684
1685 TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1686
1687 TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1688 TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1689
1690 TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1691 TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1692 TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1693 TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1694
1695 TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
1696 TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
1697
1698 END (cexp, complex);
1699 }
1700
1701
1702 static void
1703 cimag_test (void)
1704 {
1705 START (cimag);
1706 TEST_c_f (cimag, 1.0, 0.0, 0.0);
1707 TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1708 TEST_c_f (cimag, 1.0, nan_value, nan_value);
1709 TEST_c_f (cimag, nan_value, nan_value, nan_value);
1710 TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1711 TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1712 TEST_c_f (cimag, 2.0, 3.0, 3.0);
1713
1714 END (cimag);
1715 }
1716
1717 static void
1718 clog_test (void)
1719 {
1720 errno = 0;
1721 FUNC(clog) (BUILD_COMPLEX (-2, -3));
1722 if (errno == ENOSYS)
1723 /* Function not implemented. */
1724 return;
1725
1726 START (clog);
1727
1728 TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1729 TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1730
1731 TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1732 TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1733
1734 TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1735 TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1736
1737 TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1738 TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1739
1740 TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1741 TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1742 TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1743 TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1744 TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1745 TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1746 TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1747 TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1748
1749 TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1750 TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1751 TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1752 TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1753
1754 TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1755 TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1756 TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1757 TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1758
1759 TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1760 TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1761
1762 TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1763 TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1764
1765 TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1766 TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1767 TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1768 TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1769
1770 TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1771 TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1772 TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1773 TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1774
1775 TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1776
1777 TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
1778 TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
1779
1780 END (clog, complex);
1781 }
1782
1783
1784 static void
1785 clog10_test (void)
1786 {
1787 errno = 0;
1788 FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
1789 if (errno == ENOSYS)
1790 /* Function not implemented. */
1791 return;
1792
1793 START (clog10);
1794
1795 TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1796 TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1797
1798 TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1799 TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1800
1801 TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1802
1803 TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1804 TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1805
1806 TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1807 TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1808 TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1809 TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1810 TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1811 TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1812 TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1813 TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1814
1815 TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1816 TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1817 TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1818 TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1819
1820 TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1821 TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1822 TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1823 TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1824
1825 TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1826 TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1827
1828 TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1829 TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1830
1831 TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1832 TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1833 TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1834 TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1835
1836 TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1837 TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1838 TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1839 TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1840
1841 TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1842
1843 TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
1844 TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
1845
1846 END (clog10, complex);
1847 }
1848
1849
1850 static void
1851 conj_test (void)
1852 {
1853 START (conj);
1854 TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1855 TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1856 TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1857 TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1858 TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1859 TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1860 TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1861
1862 END (conj, complex);
1863 }
1864
1865
1866 static void
1867 copysign_test (void)
1868 {
1869 START (copysign);
1870
1871 TEST_ff_f (copysign, 0, 4, 0);
1872 TEST_ff_f (copysign, 0, -4, minus_zero);
1873 TEST_ff_f (copysign, minus_zero, 4, 0);
1874 TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1875
1876 TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1877 TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1878 TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1879 TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1880
1881 TEST_ff_f (copysign, 0, plus_infty, 0);
1882 TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1883 TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1884 TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1885
1886 /* XXX More correctly we would have to check the sign of the NaN. */
1887 TEST_ff_f (copysign, nan_value, 0, nan_value);
1888 TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1889 TEST_ff_f (copysign, -nan_value, 0, nan_value);
1890 TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1891
1892 END (copysign);
1893 }
1894
1895
1896 static void
1897 cos_test (void)
1898 {
1899 errno = 0;
1900 FUNC(cos) (0);
1901 if (errno == ENOSYS)
1902 /* Function not implemented. */
1903 return;
1904
1905 START (cos);
1906
1907 TEST_f_f (cos, 0, 1);
1908 TEST_f_f (cos, minus_zero, 1);
1909 TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1910 TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1911 TEST_f_f (cos, nan_value, nan_value);
1912
1913 TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
1914 TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
1915 TEST_f_f (cos, M_PI_2l, 0);
1916
1917 TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
1918
1919 #ifdef TEST_DOUBLE
1920 TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
1921 #endif
1922
1923 END (cos);
1924 }
1925
1926
1927 static void
1928 cosh_test (void)
1929 {
1930 errno = 0;
1931 FUNC(cosh) (0.7L);
1932 if (errno == ENOSYS)
1933 /* Function not implemented. */
1934 return;
1935
1936 START (cosh);
1937 TEST_f_f (cosh, 0, 1);
1938 TEST_f_f (cosh, minus_zero, 1);
1939
1940 #ifndef TEST_INLINE
1941 TEST_f_f (cosh, plus_infty, plus_infty);
1942 TEST_f_f (cosh, minus_infty, plus_infty);
1943 #endif
1944 TEST_f_f (cosh, nan_value, nan_value);
1945
1946 TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
1947
1948 END (cosh);
1949 }
1950
1951
1952 static void
1953 cpow_test (void)
1954 {
1955 errno = 0;
1956 FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
1957 if (errno == ENOSYS)
1958 /* Function not implemented. */
1959 return;
1960
1961 START (cpow);
1962
1963 TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
1964 TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
1965
1966 TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
1967 TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
1968
1969 TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
1970
1971 TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
1972 TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
1973 TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
1974 TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
1975
1976 END (cpow, complex);
1977 }
1978
1979
1980 static void
1981 cproj_test (void)
1982 {
1983 START (cproj);
1984 TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
1985 TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
1986 TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
1987 TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
1988
1989 TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
1990
1991 TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
1992 TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
1993 TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
1994 TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
1995
1996 TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
1997 TEST_c_c (cproj, 2.0, 3.0, 0.2857142857142857142857142857142857L, 0.42857142857142857142857142857142855L);
1998
1999 END (cproj, complex);
2000 }
2001
2002
2003 static void
2004 creal_test (void)
2005 {
2006 START (creal);
2007 TEST_c_f (creal, 0.0, 1.0, 0.0);
2008 TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2009 TEST_c_f (creal, nan_value, 1.0, nan_value);
2010 TEST_c_f (creal, nan_value, nan_value, nan_value);
2011 TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2012 TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2013 TEST_c_f (creal, 2.0, 3.0, 2.0);
2014
2015 END (creal);
2016 }
2017
2018 static void
2019 csin_test (void)
2020 {
2021 errno = 0;
2022 FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2023 if (errno == ENOSYS)
2024 /* Function not implemented. */
2025 return;
2026
2027 START (csin);
2028
2029 TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2030 TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2031 TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2032 TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2033
2034 TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2035 TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2036 TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2037 TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2038
2039 TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2040 TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2041 TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2042 TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2043
2044 TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2045 TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2046 TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2047 TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2048
2049 TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2050 TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2051 TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2052 TEST_c_c (csin, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2053
2054 TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2055 TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2056 TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2057 TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2058
2059 TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2060 TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2061
2062 TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2063 TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2064
2065 TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2066 TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2067
2068 TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2069 TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2070
2071 TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2072 TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2073
2074 TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2075 TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2076
2077 TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2078
2079 TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2080 TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2081
2082 END (csin, complex);
2083 }
2084
2085
2086 static void
2087 csinh_test (void)
2088 {
2089 errno = 0;
2090 FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2091 if (errno == ENOSYS)
2092 /* Function not implemented. */
2093 return;
2094
2095 START (csinh);
2096
2097 TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2098 TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2099 TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2100 TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2101
2102 TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2103 TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2104 TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2105 TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2106
2107 TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2108 TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2109 TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2110 TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2111
2112 TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2113 TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2114 TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2115 TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2116
2117 TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2118 TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2119 TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2120 TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2121
2122 TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2123 TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2124 TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2125 TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2126
2127 TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2128 TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2129
2130 TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2131 TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2132
2133 TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2134 TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2135
2136 TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2137 TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2138
2139 TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2140 TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2141
2142 TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2143 TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2144
2145 TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2146
2147 TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2148 TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2149
2150 END (csinh, complex);
2151 }
2152
2153
2154 static void
2155 csqrt_test (void)
2156 {
2157 errno = 0;
2158 FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2159 if (errno == ENOSYS)
2160 /* Function not implemented. */
2161 return;
2162
2163 START (csqrt);
2164
2165 TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2166 TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2167 TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2168 TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2169
2170 TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2171 TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2172 TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2173 TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2174
2175 TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2176 TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2177 TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2178 TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2179
2180 TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2181 TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2182 TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2183 TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2184 TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2185 TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2186 TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2187 TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2188 TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2189 TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2190 TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2191 TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2192
2193 TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2194
2195 TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2196
2197 TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2198 TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2199 TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2200 TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2201
2202 TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2203 TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2204 TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2205 TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2206
2207 TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2208
2209 TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2210 TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2211 TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2212 TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2213 TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2214 TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2215 TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2216 /* Principal square root should be returned (i.e., non-negative real
2217 part). */
2218 TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2219
2220 END (csqrt, complex);
2221 }
2222
2223 static void
2224 ctan_test (void)
2225 {
2226 errno = 0;
2227 FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2228 if (errno == ENOSYS)
2229 /* Function not implemented. */
2230 return;
2231
2232 START (ctan);
2233
2234 TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2235 TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2236 TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2237 TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2238
2239 TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2240 TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2241 TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2242 TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2243
2244 TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2245 TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2246 TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2247 TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2248
2249 TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2250 TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2251 TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2252 TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2253 TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2254 TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2255 TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2256 TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2257
2258 TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2259 TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2260
2261 TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2262 TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2263
2264 TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2265 TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2266
2267 TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2268 TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2269 TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2270 TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2271
2272 TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2273
2274 TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2275 TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2276
2277 END (ctan, complex);
2278 }
2279
2280
2281 static void
2282 ctanh_test (void)
2283 {
2284 errno = 0;
2285 FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2286 if (errno == ENOSYS)
2287 /* Function not implemented. */
2288 return;
2289
2290 START (ctanh);
2291
2292 TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2293 TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2294 TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2295 TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2296
2297 TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2298 TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2299 TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2300 TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2301 TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2302 TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2303 TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2304 TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2305
2306 TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2307 TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2308 TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2309 TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2310 TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2311 TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2312 TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2313 TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2314
2315 TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2316 TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2317
2318 TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2319 TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2320
2321 TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2322 TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2323
2324 TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2325 TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2326 TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2327 TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2328
2329 TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2330
2331 TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2332
2333 TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2334 TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2335
2336 END (ctanh, complex);
2337 }
2338
2339
2340 static void
2341 erf_test (void)
2342 {
2343 errno = 0;
2344 FUNC(erf) (0);
2345 if (errno == ENOSYS)
2346 /* Function not implemented. */
2347 return;
2348
2349 START (erf);
2350
2351 TEST_f_f (erf, 0, 0);
2352 TEST_f_f (erf, minus_zero, minus_zero);
2353 TEST_f_f (erf, plus_infty, 1);
2354 TEST_f_f (erf, minus_infty, -1);
2355 TEST_f_f (erf, nan_value, nan_value);
2356
2357 TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2358 TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2359 TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2360 TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2361 TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2362 TEST_f_f (erf, 27.0L, 1.0L);
2363
2364 END (erf);
2365 }
2366
2367
2368 static void
2369 erfc_test (void)
2370 {
2371 errno = 0;
2372 FUNC(erfc) (0);
2373 if (errno == ENOSYS)
2374 /* Function not implemented. */
2375 return;
2376
2377 START (erfc);
2378
2379 TEST_f_f (erfc, plus_infty, 0.0);
2380 TEST_f_f (erfc, minus_infty, 2.0);
2381 TEST_f_f (erfc, 0.0, 1.0);
2382 TEST_f_f (erfc, minus_zero, 1.0);
2383 TEST_f_f (erfc, nan_value, nan_value);
2384
2385 TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
2386 TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
2387 TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
2388 TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
2389 TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
2390 #ifdef TEST_LDOUBLE
2391 /* The result can only be represented in long double. */
2392 TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
2393 #endif
2394
2395 END (erfc);
2396 }
2397
2398
2399 static void
2400 exp_test (void)
2401 {
2402 errno = 0;
2403 FUNC(exp) (0);
2404 if (errno == ENOSYS)
2405 /* Function not implemented. */
2406 return;
2407
2408 START (exp);
2409
2410 TEST_f_f (exp, 0, 1);
2411 TEST_f_f (exp, minus_zero, 1);
2412
2413 #ifndef TEST_INLINE
2414 TEST_f_f (exp, plus_infty, plus_infty);
2415 TEST_f_f (exp, minus_infty, 0);
2416 #endif
2417 TEST_f_f (exp, nan_value, nan_value);
2418 TEST_f_f (exp, 1, M_El);
2419
2420 TEST_f_f (exp, 2, M_E2l);
2421 TEST_f_f (exp, 3, M_E3l);
2422 TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
2423 TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
2424 #ifdef TEST_LDOUBLE
2425 /* The result can only be represented in long double. */
2426 TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
2427 #endif
2428
2429 END (exp);
2430 }
2431
2432
2433 static void
2434 exp10_test (void)
2435 {
2436 errno = 0;
2437 FUNC(exp10) (0);
2438 if (errno == ENOSYS)
2439 /* Function not implemented. */
2440 return;
2441
2442 START (exp10);
2443
2444 TEST_f_f (exp10, 0, 1);
2445 TEST_f_f (exp10, minus_zero, 1);
2446
2447 TEST_f_f (exp10, plus_infty, plus_infty);
2448 TEST_f_f (exp10, minus_infty, 0);
2449 TEST_f_f (exp10, nan_value, nan_value);
2450 TEST_f_f (exp10, 3, 1000);
2451 TEST_f_f (exp10, -1, 0.1L);
2452 TEST_f_f (exp10, 1e6, plus_infty);
2453 TEST_f_f (exp10, -1e6, 0);
2454 TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
2455
2456 END (exp10);
2457 }
2458
2459
2460 static void
2461 exp2_test (void)
2462 {
2463 errno = 0;
2464 FUNC(exp2) (0);
2465 if (errno == ENOSYS)
2466 /* Function not implemented. */
2467 return;
2468
2469 START (exp2);
2470
2471 TEST_f_f (exp2, 0, 1);
2472 TEST_f_f (exp2, minus_zero, 1);
2473 TEST_f_f (exp2, plus_infty, plus_infty);
2474 TEST_f_f (exp2, minus_infty, 0);
2475 TEST_f_f (exp2, nan_value, nan_value);
2476
2477 TEST_f_f (exp2, 10, 1024);
2478 TEST_f_f (exp2, -1, 0.5);
2479 TEST_f_f (exp2, 1e6, plus_infty);
2480 TEST_f_f (exp2, -1e6, 0);
2481 TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
2482
2483 END (exp2);
2484 }
2485
2486
2487 static void
2488 expm1_test (void)
2489 {
2490 errno = 0;
2491 FUNC(expm1) (0);
2492 if (errno == ENOSYS)
2493 /* Function not implemented. */
2494 return;
2495
2496 START (expm1);
2497
2498 TEST_f_f (expm1, 0, 0);
2499 TEST_f_f (expm1, minus_zero, minus_zero);
2500
2501 #ifndef TEST_INLINE
2502 TEST_f_f (expm1, plus_infty, plus_infty);
2503 TEST_f_f (expm1, minus_infty, -1);
2504 #endif
2505 TEST_f_f (expm1, nan_value, nan_value);
2506
2507 TEST_f_f (expm1, 1, M_El - 1.0);
2508 TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
2509
2510 END (expm1);
2511 }
2512
2513
2514 static void
2515 fabs_test (void)
2516 {
2517 START (fabs);
2518
2519 TEST_f_f (fabs, 0, 0);
2520 TEST_f_f (fabs, minus_zero, 0);
2521
2522 TEST_f_f (fabs, plus_infty, plus_infty);
2523 TEST_f_f (fabs, minus_infty, plus_infty);
2524 TEST_f_f (fabs, nan_value, nan_value);
2525
2526 TEST_f_f (fabs, 38.0, 38.0);
2527 TEST_f_f (fabs, -M_El, M_El);
2528
2529 END (fabs);
2530 }
2531
2532
2533 static void
2534 fdim_test (void)
2535 {
2536 START (fdim);
2537
2538 TEST_ff_f (fdim, 0, 0, 0);
2539 TEST_ff_f (fdim, 9, 0, 9);
2540 TEST_ff_f (fdim, 0, 9, 0);
2541 TEST_ff_f (fdim, -9, 0, 0);
2542 TEST_ff_f (fdim, 0, -9, 9);
2543
2544 TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2545 TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2546 TEST_ff_f (fdim, minus_infty, 9, 0);
2547 TEST_ff_f (fdim, minus_infty, -9, 0);
2548 TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2549 TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2550 TEST_ff_f (fdim, 9, plus_infty, 0);
2551 TEST_ff_f (fdim, -9, plus_infty, 0);
2552
2553 TEST_ff_f (fdim, 0, nan_value, nan_value);
2554 TEST_ff_f (fdim, 9, nan_value, nan_value);
2555 TEST_ff_f (fdim, -9, nan_value, nan_value);
2556 TEST_ff_f (fdim, nan_value, 9, nan_value);
2557 TEST_ff_f (fdim, nan_value, -9, nan_value);
2558 TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2559 TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2560 TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2561 TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2562 TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2563
2564 TEST_ff_f (fdim, plus_infty, plus_infty, 0);
2565
2566 END (fdim);
2567 }
2568
2569
2570 static void
2571 floor_test (void)
2572 {
2573 START (floor);
2574
2575 TEST_f_f (floor, 0.0, 0.0);
2576 TEST_f_f (floor, minus_zero, minus_zero);
2577 TEST_f_f (floor, plus_infty, plus_infty);
2578 TEST_f_f (floor, minus_infty, minus_infty);
2579 TEST_f_f (floor, nan_value, nan_value);
2580
2581 TEST_f_f (floor, M_PIl, 3.0);
2582 TEST_f_f (floor, -M_PIl, -4.0);
2583
2584 TEST_f_f (floor, 0.25, 0.0);
2585 TEST_f_f (floor, -0.25, -1.0);
2586
2587 END (floor);
2588 }
2589
2590
2591 static void
2592 fma_test (void)
2593 {
2594 START (fma);
2595
2596 TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2597 TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2598 TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2599 TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2600 TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2601 TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2602 TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2603 TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2604 TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2605 TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2606 TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2607 TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2608
2609 TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2610 TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2611 TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2612 TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2613
2614 TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
2615
2616 END (fma);
2617 }
2618
2619
2620 static void
2621 fmax_test (void)
2622 {
2623 START (fmax);
2624
2625 TEST_ff_f (fmax, 0, 0, 0);
2626 TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2627 TEST_ff_f (fmax, 9, 0, 9);
2628 TEST_ff_f (fmax, 0, 9, 9);
2629 TEST_ff_f (fmax, -9, 0, 0);
2630 TEST_ff_f (fmax, 0, -9, 0);
2631
2632 TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2633 TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2634 TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2635 TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2636
2637 TEST_ff_f (fmax, minus_infty, 9, 9);
2638 TEST_ff_f (fmax, minus_infty, -9, -9);
2639 TEST_ff_f (fmax, 9, minus_infty, 9);
2640 TEST_ff_f (fmax, -9, minus_infty, -9);
2641
2642 TEST_ff_f (fmax, 0, nan_value, 0);
2643 TEST_ff_f (fmax, 9, nan_value, 9);
2644 TEST_ff_f (fmax, -9, nan_value, -9);
2645 TEST_ff_f (fmax, nan_value, 0, 0);
2646 TEST_ff_f (fmax, nan_value, 9, 9);
2647 TEST_ff_f (fmax, nan_value, -9, -9);
2648 TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2649 TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2650 TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2651 TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2652 TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2653
2654 END (fmax);
2655 }
2656
2657
2658 static void
2659 fmin_test (void)
2660 {
2661 START (fmin);
2662
2663 TEST_ff_f (fmin, 0, 0, 0);
2664 TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2665 TEST_ff_f (fmin, 9, 0, 0);
2666 TEST_ff_f (fmin, 0, 9, 0);
2667 TEST_ff_f (fmin, -9, 0, -9);
2668 TEST_ff_f (fmin, 0, -9, -9);
2669
2670 TEST_ff_f (fmin, plus_infty, 9, 9);
2671 TEST_ff_f (fmin, 9, plus_infty, 9);
2672 TEST_ff_f (fmin, plus_infty, -9, -9);
2673 TEST_ff_f (fmin, -9, plus_infty, -9);
2674 TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2675 TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2676 TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2677 TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2678
2679 TEST_ff_f (fmin, 0, nan_value, 0);
2680 TEST_ff_f (fmin, 9, nan_value, 9);
2681 TEST_ff_f (fmin, -9, nan_value, -9);
2682 TEST_ff_f (fmin, nan_value, 0, 0);
2683 TEST_ff_f (fmin, nan_value, 9, 9);
2684 TEST_ff_f (fmin, nan_value, -9, -9);
2685 TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2686 TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2687 TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2688 TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2689 TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2690
2691 END (fmin);
2692 }
2693
2694
2695 static void
2696 fmod_test (void)
2697 {
2698 errno = 0;
2699 FUNC(fmod) (6.5, 2.3L);
2700 if (errno == ENOSYS)
2701 /* Function not implemented. */
2702 return;
2703
2704 START (fmod);
2705
2706 /* fmod (+0, y) == +0 for y != 0. */
2707 TEST_ff_f (fmod, 0, 3, 0);
2708
2709 /* fmod (-0, y) == -0 for y != 0. */
2710 TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2711
2712 /* fmod (+inf, y) == NaN plus invalid exception. */
2713 TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2714 /* fmod (-inf, y) == NaN plus invalid exception. */
2715 TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2716 /* fmod (x, +0) == NaN plus invalid exception. */
2717 TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2718 /* fmod (x, -0) == NaN plus invalid exception. */
2719 TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2720
2721 /* fmod (x, +inf) == x for x not infinite. */
2722 TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2723 /* fmod (x, -inf) == x for x not infinite. */
2724 TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2725
2726 TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2727
2728 TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
2729 TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
2730 TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
2731 TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
2732
2733 END (fmod);
2734 }
2735
2736
2737 static void
2738 fpclassify_test (void)
2739 {
2740 START (fpclassify);
2741
2742 TEST_f_i (fpclassify, nan_value, FP_NAN);
2743 TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2744 TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2745 TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2746 TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2747 TEST_f_i (fpclassify, 1000, FP_NORMAL);
2748
2749 END (fpclassify);
2750 }
2751
2752
2753 static void
2754 frexp_test (void)
2755 {
2756 int x;
2757
2758 START (frexp);
2759
2760 TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2761 TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2762 TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2763
2764 TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2765 TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2766
2767 TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
2768 TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
2769
2770 END (frexp);
2771 }
2772
2773
2774 static void
2775 gamma_test (void)
2776 {
2777 errno = 0;
2778 FUNC(gamma) (1);
2779
2780 if (errno == ENOSYS)
2781 /* Function not implemented. */
2782 return;
2783 feclearexcept (FE_ALL_EXCEPT);
2784
2785 START (gamma);
2786
2787 TEST_f_f (gamma, plus_infty, plus_infty);
2788 TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2789 TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2790 TEST_f_f (gamma, minus_infty, plus_infty);
2791 TEST_f_f (gamma, nan_value, nan_value);
2792
2793 TEST_f_f1 (gamma, 1, 0, 1);
2794 TEST_f_f1 (gamma, 3, M_LN2l, 1);
2795
2796 TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2797 TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2798
2799 END (gamma);
2800 }
2801
2802 static void
2803 hypot_test (void)
2804 {
2805 errno = 0;
2806 FUNC(hypot) (0.7L, 12.4L);
2807 if (errno == ENOSYS)
2808 /* Function not implemented. */
2809 return;
2810
2811 START (hypot);
2812
2813 TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2814 TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2815
2816 #ifndef TEST_INLINE
2817 TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2818 TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2819 TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2820 TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2821 #endif
2822
2823 TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2824
2825 /* hypot (x,y) == hypot (+-x, +-y) */
2826 TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
2827 TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
2828 TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
2829 TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
2830 TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
2831 TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
2832 TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
2833 TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
2834
2835 /* hypot (x,0) == fabs (x) */
2836 TEST_ff_f (hypot, 0.75L, 0, 0.75L);
2837 TEST_ff_f (hypot, -0.75L, 0, 0.75L);
2838 TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
2839
2840 TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
2841
2842 END (hypot);
2843 }
2844
2845
2846 static void
2847 ilogb_test (void)
2848 {
2849 START (ilogb);
2850
2851 TEST_f_i (ilogb, 1, 0);
2852 TEST_f_i (ilogb, M_El, 1);
2853 TEST_f_i (ilogb, 1024, 10);
2854 TEST_f_i (ilogb, -2000, 10);
2855
2856 /* XXX We have a problem here: the standard does not tell us whether
2857 exceptions are allowed/required. ignore them for now. */
2858
2859 TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
2860 TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
2861 TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
2862 TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
2863
2864 END (ilogb);
2865 }
2866
2867 static void
2868 isfinite_test (void)
2869 {
2870 START (isfinite);
2871
2872 TEST_f_b (isfinite, 0, 1);
2873 TEST_f_b (isfinite, minus_zero, 1);
2874 TEST_f_b (isfinite, 10, 1);
2875 TEST_f_b (isfinite, plus_infty, 0);
2876 TEST_f_b (isfinite, minus_infty, 0);
2877 TEST_f_b (isfinite, nan_value, 0);
2878
2879 END (isfinite);
2880 }
2881
2882 static void
2883 isnormal_test (void)
2884 {
2885 START (isnormal);
2886
2887 TEST_f_b (isnormal, 0, 0);
2888 TEST_f_b (isnormal, minus_zero, 0);
2889 TEST_f_b (isnormal, 10, 1);
2890 TEST_f_b (isnormal, plus_infty, 0);
2891 TEST_f_b (isnormal, minus_infty, 0);
2892 TEST_f_b (isnormal, nan_value, 0);
2893
2894 END (isnormal);
2895 }
2896
2897 static void
2898 j0_test (void)
2899 {
2900 FLOAT s, c;
2901 errno = 0;
2902 FUNC (sincos) (0, &s, &c);
2903 if (errno == ENOSYS)
2904 /* Required function not implemented. */
2905 return;
2906 FUNC(j0) (0);
2907 if (errno == ENOSYS)
2908 /* Function not implemented. */
2909 return;
2910
2911 START (j0);
2912
2913 /* j0 is the Bessel function of the first kind of order 0 */
2914 TEST_f_f (j0, nan_value, nan_value);
2915 TEST_f_f (j0, plus_infty, 0);
2916 TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
2917 TEST_f_f (j0, 0.0, 1.0);
2918 TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
2919 TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
2920 TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
2921 TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
2922 TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
2923 TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
2924 TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
2925 TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
2926 TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
2927
2928 END (j0);
2929 }
2930
2931
2932 static void
2933 j1_test (void)
2934 {
2935 FLOAT s, c;
2936 errno = 0;
2937 FUNC (sincos) (0, &s, &c);
2938 if (errno == ENOSYS)
2939 /* Required function not implemented. */
2940 return;
2941 FUNC(j1) (0);
2942 if (errno == ENOSYS)
2943 /* Function not implemented. */
2944 return;
2945
2946 /* j1 is the Bessel function of the first kind of order 1 */
2947
2948 START (j1);
2949
2950 TEST_f_f (j1, nan_value, nan_value);
2951 TEST_f_f (j1, plus_infty, 0);
2952
2953 TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
2954 TEST_f_f (j1, 0.0, 0.0);
2955 TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
2956 TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
2957 TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
2958 TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
2959 TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
2960 TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
2961 TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
2962
2963 END (j1);
2964 }
2965
2966 static void
2967 jn_test (void)
2968 {
2969 FLOAT s, c;
2970 errno = 0;
2971 FUNC (sincos) (0, &s, &c);
2972 if (errno == ENOSYS)
2973 /* Required function not implemented. */
2974 return;
2975 FUNC(jn) (1, 1);
2976 if (errno == ENOSYS)
2977 /* Function not implemented. */
2978 return;
2979
2980 /* jn is the Bessel function of the first kind of order n. */
2981 START (jn);
2982
2983 /* jn (0, x) == j0 (x) */
2984 TEST_ff_f (jn, 0, nan_value, nan_value);
2985 TEST_ff_f (jn, 0, plus_infty, 0);
2986 TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
2987 TEST_ff_f (jn, 0, 0.0, 1.0);
2988 TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
2989 TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
2990 TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
2991 TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
2992 TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
2993 TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
2994 TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
2995 TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
2996 TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
2997
2998 /* jn (1, x) == j1 (x) */
2999 TEST_ff_f (jn, 1, nan_value, nan_value);
3000 TEST_ff_f (jn, 1, plus_infty, 0);
3001 TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3002 TEST_ff_f (jn, 1, 0.0, 0.0);
3003 TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3004 TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3005 TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3006 TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3007 TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3008 TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3009 TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3010
3011 /* jn (3, x) */
3012 TEST_ff_f (jn, 3, nan_value, nan_value);
3013 TEST_ff_f (jn, 3, plus_infty, 0);
3014
3015 TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3016 TEST_ff_f (jn, 3, 0.0, 0.0);
3017 TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3018 TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3019 TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3020 TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3021 TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3022
3023 /* jn (10, x) */
3024 TEST_ff_f (jn, 10, nan_value, nan_value);
3025 TEST_ff_f (jn, 10, plus_infty, 0);
3026
3027 TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3028 TEST_ff_f (jn, 10, 0.0, 0.0);
3029 TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3030 TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3031 TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3032 TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3033 TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3034
3035 END (jn);
3036 }
3037
3038
3039 static void
3040 ldexp_test (void)
3041 {
3042 TEST_ff_f (ldexp, 0, 0, 0);
3043 TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3044
3045 TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3046 TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3047 TEST_ff_f (ldexp, nan_value, 1, nan_value);
3048
3049 TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3050 TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3051
3052 /* ldexp (x, 0) == x. */
3053 TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3054 }
3055
3056
3057 static void
3058 lgamma_test (void)
3059 {
3060 errno = 0;
3061 FUNC(lgamma) (0);
3062 if (errno == ENOSYS)
3063 /* Function not implemented. */
3064 return;
3065 feclearexcept (FE_ALL_EXCEPT);
3066
3067 START (lgamma);
3068
3069 TEST_f_f (lgamma, plus_infty, plus_infty);
3070 TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3071 TEST_f_f (lgamma, nan_value, nan_value);
3072
3073 /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0. */
3074 TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3075 TEST_f_f (lgamma, minus_infty, plus_infty);
3076
3077 TEST_f_f1 (lgamma, 1, 0, 1);
3078
3079 TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3080
3081 TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3082 TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3083 TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3084 TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3085
3086 END (lgamma);
3087 }
3088
3089
3090 static void
3091 lrint_test (void)
3092 {
3093 /* XXX this test is incomplete. We need to have a way to specifiy
3094 the rounding method and test the critical cases. So far, only
3095 unproblematic numbers are tested. */
3096
3097 START (lrint);
3098
3099 TEST_f_l (lrint, 0.0, 0);
3100 TEST_f_l (lrint, minus_zero, 0);
3101 TEST_f_l (lrint, 0.2L, 0);
3102 TEST_f_l (lrint, -0.2L, 0);
3103
3104 TEST_f_l (lrint, 1.4L, 1);
3105 TEST_f_l (lrint, -1.4L, -1);
3106
3107 TEST_f_l (lrint, 8388600.3L, 8388600);
3108 TEST_f_l (lrint, -8388600.3L, -8388600);
3109
3110 TEST_f_l (lrint, 1071930.0008, 1071930);
3111 #ifndef TEST_FLOAT
3112 TEST_f_l (lrint, 1073741824.01, 1073741824);
3113 # if LONG_MAX > 281474976710656
3114 TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3115 # endif
3116 #endif
3117
3118 END (lrint);
3119 }
3120
3121
3122 static void
3123 llrint_test (void)
3124 {
3125 /* XXX this test is incomplete. We need to have a way to specifiy
3126 the rounding method and test the critical cases. So far, only
3127 unproblematic numbers are tested. */
3128
3129 START (llrint);
3130
3131 TEST_f_L (llrint, 0.0, 0);
3132 TEST_f_L (llrint, minus_zero, 0);
3133 TEST_f_L (llrint, 0.2L, 0);
3134 TEST_f_L (llrint, -0.2L, 0);
3135
3136 TEST_f_L (llrint, 1.4L, 1);
3137 TEST_f_L (llrint, -1.4L, -1);
3138
3139 TEST_f_L (llrint, 8388600.3L, 8388600);
3140 TEST_f_L (llrint, -8388600.3L, -8388600);
3141
3142 TEST_f_l (llrint, 1071930.0008, 1071930);
3143
3144 /* Test boundary conditions. */
3145 /* 0x1FFFFF */
3146 TEST_f_L (llrint, 2097151.0,2097151LL);
3147 /* 0x800000 */
3148 TEST_f_L (llrint, 8388608.0, 8388608LL);
3149 /* 0x1000000 */
3150 TEST_f_L (llrint, 16777216.0, 16777216LL);
3151 /* 0x20000000000 */
3152 TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3153 /* 0x40000000000 */
3154 TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3155 /* 0x1000000000000 */
3156 TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3157 /* 0x10000000000000 */
3158 TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3159 /* 0x10000080000000 */
3160 TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3161 /* 0x20000000000000 */
3162 TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3163 /* 0x80000000000000 */
3164 TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3165 /* 0x100000000000000 */
3166 TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3167
3168 END (llrint);
3169 }
3170
3171
3172 static void
3173 log_test (void)
3174 {
3175 errno = 0;
3176 FUNC(log) (1);
3177 if (errno == ENOSYS)
3178 /* Function not implemented. */
3179 return;
3180 START (log);
3181
3182 TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3183 TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3184
3185 TEST_f_f (log, 1, 0);
3186
3187 TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
3188 TEST_f_f (log, plus_infty, plus_infty);
3189
3190 TEST_f_f (log, M_El, 1);
3191 TEST_f_f (log, 1.0 / M_El, -1);
3192 TEST_f_f (log, 2, M_LN2l);
3193 TEST_f_f (log, 10, M_LN10l);
3194 TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
3195
3196 END (log);
3197 }
3198
3199
3200 static void
3201 log10_test (void)
3202 {
3203 errno = 0;
3204 FUNC(log10) (1);
3205 if (errno == ENOSYS)
3206 /* Function not implemented. */
3207 return;
3208
3209 START (log10);
3210
3211 TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3212 TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3213
3214 TEST_f_f (log10, 1, 0);
3215
3216 /* log10 (x) == NaN plus invalid exception if x < 0. */
3217 TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
3218
3219 TEST_f_f (log10, plus_infty, plus_infty);
3220 TEST_f_f (log10, nan_value, nan_value);
3221
3222 TEST_f_f (log10, 0.1L, -1);
3223 TEST_f_f (log10, 10.0, 1);
3224 TEST_f_f (log10, 100.0, 2);
3225 TEST_f_f (log10, 10000.0, 4);
3226 TEST_f_f (log10, M_El, M_LOG10El);
3227 TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
3228
3229 END (log10);
3230 }
3231
3232
3233 static void
3234 log1p_test (void)
3235 {
3236 errno = 0;
3237 FUNC(log1p) (0);
3238 if (errno == ENOSYS)
3239 /* Function not implemented. */
3240 return;
3241
3242 START (log1p);
3243
3244 TEST_f_f (log1p, 0, 0);
3245 TEST_f_f (log1p, minus_zero, minus_zero);
3246
3247 TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3248 TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
3249
3250 TEST_f_f (log1p, plus_infty, plus_infty);
3251 TEST_f_f (log1p, nan_value, nan_value);
3252
3253 TEST_f_f (log1p, M_El - 1.0, 1);
3254
3255 TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
3256 TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
3257
3258 END (log1p);
3259 }
3260
3261
3262 static void
3263 log2_test (void)
3264 {
3265 errno = 0;
3266 FUNC(log2) (1);
3267 if (errno == ENOSYS)
3268 /* Function not implemented. */
3269 return;
3270
3271 START (log2);
3272
3273 TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3274 TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3275
3276 TEST_f_f (log2, 1, 0);
3277
3278 TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
3279
3280 TEST_f_f (log2, plus_infty, plus_infty);
3281 TEST_f_f (log2, nan_value, nan_value);
3282
3283 TEST_f_f (log2, M_El, M_LOG2El);
3284 TEST_f_f (log2, 2.0, 1);
3285 TEST_f_f (log2, 16.0, 4);
3286 TEST_f_f (log2, 256.0, 8);
3287 TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
3288
3289 END (log2);
3290 }
3291
3292
3293 static void
3294 logb_test (void)
3295 {
3296 START (logb);
3297
3298 TEST_f_f (logb, plus_infty, plus_infty);
3299 TEST_f_f (logb, minus_infty, plus_infty);
3300
3301 TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3302
3303 TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3304 TEST_f_f (logb, nan_value, nan_value);
3305
3306 TEST_f_f (logb, 1, 0);
3307 TEST_f_f (logb, M_El, 1);
3308 TEST_f_f (logb, 1024, 10);
3309 TEST_f_f (logb, -2000, 10);
3310
3311 END (logb);
3312 }
3313
3314
3315 static void
3316 lround_test (void)
3317 {
3318 START (lround);
3319
3320 TEST_f_l (lround, 0, 0);
3321 TEST_f_l (lround, minus_zero, 0);
3322 TEST_f_l (lround, 0.2L, 0.0);
3323 TEST_f_l (lround, -0.2L, 0);
3324 TEST_f_l (lround, 0.5, 1);
3325 TEST_f_l (lround, -0.5, -1);
3326 TEST_f_l (lround, 0.8L, 1);
3327 TEST_f_l (lround, -0.8L, -1);
3328 TEST_f_l (lround, 1.5, 2);
3329 TEST_f_l (lround, -1.5, -2);
3330 TEST_f_l (lround, 22514.5, 22515);
3331 TEST_f_l (lround, -22514.5, -22515);
3332 TEST_f_l (lround, 1071930.0008, 1071930);
3333 #ifndef TEST_FLOAT
3334 TEST_f_l (lround, 1073741824.01, 1073741824);
3335 # if LONG_MAX > 281474976710656
3336 TEST_f_l (lround, 281474976710656.025, 281474976710656);
3337 # endif
3338 TEST_f_l (lround, 2097152.5, 2097153);
3339 TEST_f_l (lround, -2097152.5, -2097153);
3340 #endif
3341 END (lround);
3342 }
3343
3344
3345 static void
3346 llround_test (void)
3347 {
3348 START (llround);
3349
3350 TEST_f_L (llround, 0, 0);
3351 TEST_f_L (llround, minus_zero, 0);
3352 TEST_f_L (llround, 0.2L, 0.0);
3353 TEST_f_L (llround, -0.2L, 0);
3354 TEST_f_L (llround, 0.5, 1);
3355 TEST_f_L (llround, -0.5, -1);
3356 TEST_f_L (llround, 0.8L, 1);
3357 TEST_f_L (llround, -0.8L, -1);
3358 TEST_f_L (llround, 1.5, 2);
3359 TEST_f_L (llround, -1.5, -2);
3360 TEST_f_L (llround, 22514.5, 22515);
3361 TEST_f_L (llround, -22514.5, -22515);
3362 TEST_f_l (llround, 1071930.0008, 1071930);
3363 #ifndef TEST_FLOAT
3364 TEST_f_L (llround, 2097152.5, 2097153);
3365 TEST_f_L (llround, -2097152.5, -2097153);
3366 TEST_f_L (llround, 34359738368.5, 34359738369ll);
3367 TEST_f_L (llround, -34359738368.5, -34359738369ll);
3368 #endif
3369
3370 /* Test boundary conditions. */
3371 /* 0x1FFFFF */
3372 TEST_f_L (llround, 2097151.0, 2097151LL);
3373 /* 0x800000 */
3374 TEST_f_L (llround, 8388608.0, 8388608LL);
3375 /* 0x1000000 */
3376 TEST_f_L (llround, 16777216.0, 16777216LL);
3377 /* 0x20000000000 */
3378 TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3379 /* 0x40000000000 */
3380 TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3381 /* 0x1000000000000 */
3382 TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
3383 /* 0x10000000000000 */
3384 TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3385 /* 0x10000080000000 */
3386 TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
3387 /* 0x20000000000000 */
3388 TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3389 /* 0x80000000000000 */
3390 TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3391 /* 0x100000000000000 */
3392 TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3393
3394 #ifndef TEST_FLOAT
3395 /* 0x100000000 */
3396 TEST_f_L (llround, 4294967295.5, 4294967296LL);
3397 /* 0x200000000 */
3398 TEST_f_L (llround, 8589934591.5, 8589934592LL);
3399 #endif
3400
3401 END (llround);
3402 }
3403
3404 static void
3405 modf_test (void)
3406 {
3407 FLOAT x;
3408
3409 START (modf);
3410
3411 TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3412 TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3413 TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3414 TEST_fF_f1 (modf, 0, 0, 0);
3415 TEST_fF_f1 (modf, 1.5, 0.5, 1);
3416 TEST_fF_f1 (modf, 2.5, 0.5, 2);
3417 TEST_fF_f1 (modf, -2.5, -0.5, -2);
3418 TEST_fF_f1 (modf, 20, 0, 20);
3419 TEST_fF_f1 (modf, 21, 0, 21);
3420 TEST_fF_f1 (modf, 89.5, 0.5, 89);
3421
3422 END (modf);
3423 }
3424
3425
3426 static void
3427 nearbyint_test (void)
3428 {
3429 START (nearbyint);
3430
3431 TEST_f_f (nearbyint, 0.0, 0.0);
3432 TEST_f_f (nearbyint, minus_zero, minus_zero);
3433 TEST_f_f (nearbyint, plus_infty, plus_infty);
3434 TEST_f_f (nearbyint, minus_infty, minus_infty);
3435 TEST_f_f (nearbyint, nan_value, nan_value);
3436
3437 /* Default rounding mode is round to nearest. */
3438 TEST_f_f (nearbyint, 0.5, 0.0);
3439 TEST_f_f (nearbyint, 1.5, 2.0);
3440 TEST_f_f (nearbyint, -0.5, minus_zero);
3441 TEST_f_f (nearbyint, -1.5, -2.0);
3442
3443 END (nearbyint);
3444 }
3445
3446 static void
3447 nextafter_test (void)
3448 {
3449
3450 START (nextafter);
3451
3452 TEST_ff_f (nextafter, 0, 0, 0);
3453 TEST_ff_f (nextafter, minus_zero, 0, 0);
3454 TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3455 TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3456
3457 TEST_ff_f (nextafter, 9, 9, 9);
3458 TEST_ff_f (nextafter, -9, -9, -9);
3459 TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3460 TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3461
3462 TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
3463 TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
3464 TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3465
3466 FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3467 LDBL_MAX, DBL_MAX, FLT_MAX);
3468 TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty);
3469 TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty);
3470
3471 #ifdef TEST_LDOUBLE
3472 // XXX Enable once gcc is fixed.
3473 //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
3474 #endif
3475
3476 /* XXX We need the hexadecimal FP number representation here for further
3477 tests. */
3478
3479 END (nextafter);
3480 }
3481
3482
3483 static void
3484 nexttoward_test (void)
3485 {
3486 START (nexttoward);
3487 TEST_ff_f (nexttoward, 0, 0, 0);
3488 TEST_ff_f (nexttoward, minus_zero, 0, 0);
3489 TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3490 TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3491
3492 TEST_ff_f (nexttoward, 9, 9, 9);
3493 TEST_ff_f (nexttoward, -9, -9, -9);
3494 TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3495 TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3496
3497 TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
3498 TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
3499 TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3500
3501 /* XXX We need the hexadecimal FP number representation here for further
3502 tests. */
3503
3504 END (nexttoward);
3505 }
3506
3507
3508 static void
3509 pow_test (void)
3510 {
3511
3512 errno = 0;
3513 FUNC(pow) (0, 0);
3514 if (errno == ENOSYS)
3515 /* Function not implemented. */
3516 return;
3517
3518 START (pow);
3519
3520 TEST_ff_f (pow, 0, 0, 1);
3521 TEST_ff_f (pow, 0, minus_zero, 1);
3522 TEST_ff_f (pow, minus_zero, 0, 1);
3523 TEST_ff_f (pow, minus_zero, minus_zero, 1);
3524
3525 TEST_ff_f (pow, 10, 0, 1);
3526 TEST_ff_f (pow, 10, minus_zero, 1);
3527 TEST_ff_f (pow, -10, 0, 1);
3528 TEST_ff_f (pow, -10, minus_zero, 1);
3529
3530 TEST_ff_f (pow, nan_value, 0, 1);
3531 TEST_ff_f (pow, nan_value, minus_zero, 1);
3532
3533
3534 #ifndef TEST_INLINE
3535 TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
3536 TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3537 TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
3538 TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3539
3540 TEST_ff_f (pow, 0.9L, plus_infty, 0);
3541 TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3542 TEST_ff_f (pow, -0.9L, plus_infty, 0);
3543 TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3544
3545 TEST_ff_f (pow, 1.1L, minus_infty, 0);
3546 TEST_ff_f (pow, plus_infty, minus_infty, 0);
3547 TEST_ff_f (pow, -1.1L, minus_infty, 0);
3548 TEST_ff_f (pow, minus_infty, minus_infty, 0);
3549
3550 TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3551 TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3552 TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3553 TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3554
3555 TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3556 TEST_ff_f (pow, plus_infty, 1, plus_infty);
3557 TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3558
3559 TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3560 TEST_ff_f (pow, plus_infty, -1, 0);
3561 TEST_ff_f (pow, plus_infty, -1e7L, 0);
3562
3563 TEST_ff_f (pow, minus_infty, 1, minus_infty);
3564 TEST_ff_f (pow, minus_infty, 11, minus_infty);
3565 TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3566
3567 TEST_ff_f (pow, minus_infty, 2, plus_infty);
3568 TEST_ff_f (pow, minus_infty, 12, plus_infty);
3569 TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3570 TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
3571 TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
3572 TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
3573 TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
3574
3575 TEST_ff_f (pow, minus_infty, -1, minus_zero);
3576 TEST_ff_f (pow, minus_infty, -11, minus_zero);
3577 TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3578
3579 TEST_ff_f (pow, minus_infty, -2, 0);
3580 TEST_ff_f (pow, minus_infty, -12, 0);
3581 TEST_ff_f (pow, minus_infty, -1002, 0);
3582 TEST_ff_f (pow, minus_infty, -0.1L, 0);
3583 TEST_ff_f (pow, minus_infty, -1.1L, 0);
3584 TEST_ff_f (pow, minus_infty, -11.1L, 0);
3585 TEST_ff_f (pow, minus_infty, -1001.1L, 0);
3586 #endif
3587
3588 TEST_ff_f (pow, nan_value, nan_value, nan_value);
3589 TEST_ff_f (pow, 0, nan_value, nan_value);
3590 TEST_ff_f (pow, 1, nan_value, 1);
3591 TEST_ff_f (pow, -1, nan_value, nan_value);
3592 TEST_ff_f (pow, nan_value, 1, nan_value);
3593 TEST_ff_f (pow, nan_value, -1, nan_value);
3594
3595 /* pow (x, NaN) == NaN. */
3596 TEST_ff_f (pow, 3.0, nan_value, nan_value);
3597
3598 TEST_ff_f (pow, 1, plus_infty, 1);
3599 TEST_ff_f (pow, -1, plus_infty, 1);
3600 TEST_ff_f (pow, 1, minus_infty, 1);
3601 TEST_ff_f (pow, -1, minus_infty, 1);
3602 TEST_ff_f (pow, 1, 1, 1);
3603 TEST_ff_f (pow, 1, -1, 1);
3604 TEST_ff_f (pow, 1, 1.25, 1);
3605 TEST_ff_f (pow, 1, -1.25, 1);
3606 TEST_ff_f (pow, 1, 0x1p62L, 1);
3607 TEST_ff_f (pow, 1, 0x1p63L, 1);
3608 TEST_ff_f (pow, 1, 0x1p64L, 1);
3609 TEST_ff_f (pow, 1, 0x1p72L, 1);
3610
3611 /* pow (x, +-0) == 1. */
3612 TEST_ff_f (pow, plus_infty, 0, 1);
3613 TEST_ff_f (pow, plus_infty, minus_zero, 1);
3614 TEST_ff_f (pow, minus_infty, 0, 1);
3615 TEST_ff_f (pow, minus_infty, minus_zero, 1);
3616 TEST_ff_f (pow, 32.75L, 0, 1);
3617 TEST_ff_f (pow, 32.75L, minus_zero, 1);
3618 TEST_ff_f (pow, -32.75L, 0, 1);
3619 TEST_ff_f (pow, -32.75L, minus_zero, 1);
3620 TEST_ff_f (pow, 0x1p72L, 0, 1);
3621 TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
3622 TEST_ff_f (pow, 0x1p-72L, 0, 1);
3623 TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
3624
3625 TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3626 TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3627 TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3628 TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3629
3630 TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3631 TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3632 TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3633 TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3634
3635 TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3636 TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3637 TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3638 TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3639
3640 TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty);
3641 TEST_ff_f (pow, 10, -0x1p72L, 0);
3642 TEST_ff_f (pow, max_value, max_value, plus_infty);
3643 TEST_ff_f (pow, 10, -max_value, 0);
3644
3645 TEST_ff_f (pow, 0, 1, 0);
3646 TEST_ff_f (pow, 0, 11, 0);
3647
3648 TEST_ff_f (pow, minus_zero, 1, minus_zero);
3649 TEST_ff_f (pow, minus_zero, 11, minus_zero);
3650
3651
3652 TEST_ff_f (pow, 0, 2, 0);
3653 TEST_ff_f (pow, 0, 11.1L, 0);
3654
3655
3656 TEST_ff_f (pow, minus_zero, 2, 0);
3657 TEST_ff_f (pow, minus_zero, 11.1L, 0);
3658 TEST_ff_f (pow, 0, plus_infty, 0);
3659 TEST_ff_f (pow, minus_zero, plus_infty, 0);
3660
3661 #ifndef TEST_INLINE
3662 /* pow (x, +inf) == +inf for |x| > 1. */
3663 TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3664
3665 /* pow (x, +inf) == +0 for |x| < 1. */
3666 TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3667
3668 /* pow (x, -inf) == +0 for |x| > 1. */
3669 TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3670
3671 /* pow (x, -inf) == +inf for |x| < 1. */
3672 TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3673 #endif
3674
3675 /* pow (+inf, y) == +inf for y > 0. */
3676 TEST_ff_f (pow, plus_infty, 2, plus_infty);
3677
3678 /* pow (+inf, y) == +0 for y < 0. */
3679 TEST_ff_f (pow, plus_infty, -1, 0.0);
3680
3681 /* pow (-inf, y) == -inf for y an odd integer > 0. */
3682 TEST_ff_f (pow, minus_infty, 27, minus_infty);
3683
3684 /* pow (-inf, y) == +inf for y > 0 and not an odd integer. */
3685 TEST_ff_f (pow, minus_infty, 28, plus_infty);
3686
3687 /* pow (-inf, y) == -0 for y an odd integer < 0. */
3688 TEST_ff_f (pow, minus_infty, -3, minus_zero);
3689 /* pow (-inf, y) == +0 for y < 0 and not an odd integer. */
3690 TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3691
3692 /* pow (+0, y) == +0 for y an odd integer > 0. */
3693 TEST_ff_f (pow, 0.0, 27, 0.0);
3694
3695 /* pow (-0, y) == -0 for y an odd integer > 0. */
3696 TEST_ff_f (pow, minus_zero, 27, minus_zero);
3697
3698 /* pow (+0, y) == +0 for y > 0 and not an odd integer. */
3699 TEST_ff_f (pow, 0.0, 4, 0.0);
3700
3701 /* pow (-0, y) == +0 for y > 0 and not an odd integer. */
3702 TEST_ff_f (pow, minus_zero, 4, 0.0);
3703
3704 TEST_ff_f (pow, 16, 0.25L, 2);
3705 TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
3706 TEST_ff_f (pow, 2, 4, 16);
3707 TEST_ff_f (pow, 256, 8, 0x1p64L);
3708
3709 TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
3710
3711 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
3712 TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3713 #endif
3714
3715 END (pow);
3716 }
3717
3718 static void
3719 remainder_test (void)
3720 {
3721 errno = 0;
3722 FUNC(remainder) (1.625, 1.0);
3723 if (errno == ENOSYS)
3724 /* Function not implemented. */
3725 return;
3726
3727 START (remainder);
3728
3729 TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3730 TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3731 TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3732 TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3733 TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3734
3735 TEST_ff_f (remainder, 1.625, 1.0, -0.375);
3736 TEST_ff_f (remainder, -1.625, 1.0, 0.375);
3737 TEST_ff_f (remainder, 1.625, -1.0, -0.375);
3738 TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3739 TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3740 TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3741
3742 END (remainder);
3743 }
3744
3745 static void
3746 remquo_test (void)
3747 {
3748 /* x is needed. */
3749 int x;
3750
3751 errno = 0;
3752 FUNC(remquo) (1.625, 1.0, &x);
3753 if (errno == ENOSYS)
3754 /* Function not implemented. */
3755 return;
3756
3757 START (remquo);
3758
3759 TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3760 TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3761 TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3762 TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3763 TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3764
3765 TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
3766 TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
3767 TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3768 TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3769
3770 TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3771 TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3772
3773 END (remquo);
3774 }
3775
3776 static void
3777 rint_test (void)
3778 {
3779 START (rint);
3780
3781 TEST_f_f (rint, 0.0, 0.0);
3782 TEST_f_f (rint, minus_zero, minus_zero);
3783 TEST_f_f (rint, plus_infty, plus_infty);
3784 TEST_f_f (rint, minus_infty, minus_infty);
3785
3786 /* Default rounding mode is round to even. */
3787 TEST_f_f (rint, 0.5, 0.0);
3788 TEST_f_f (rint, 1.5, 2.0);
3789 TEST_f_f (rint, 2.5, 2.0);
3790 TEST_f_f (rint, 3.5, 4.0);
3791 TEST_f_f (rint, 4.5, 4.0);
3792 TEST_f_f (rint, -0.5, -0.0);
3793 TEST_f_f (rint, -1.5, -2.0);
3794 TEST_f_f (rint, -2.5, -2.0);
3795 TEST_f_f (rint, -3.5, -4.0);
3796 TEST_f_f (rint, -4.5, -4.0);
3797
3798 END (rint);
3799 }
3800
3801 static void
3802 rint_test_tonearest (void)
3803 {
3804 int save_round_mode;
3805 START (rint_tonearest);
3806
3807 save_round_mode = fegetround();
3808
3809 if (!fesetround (FE_TONEAREST))
3810 {
3811 TEST_f_f (rint, 2.0, 2.0);
3812 TEST_f_f (rint, 1.5, 2.0);
3813 TEST_f_f (rint, 1.0, 1.0);
3814 TEST_f_f (rint, 0.5, 0.0);
3815 TEST_f_f (rint, 0.0, 0.0);
3816 TEST_f_f (rint, minus_zero, minus_zero);
3817 TEST_f_f (rint, -0.5, -0.0);
3818 TEST_f_f (rint, -1.0, -1.0);
3819 TEST_f_f (rint, -1.5, -2.0);
3820 TEST_f_f (rint, -2.0, -2.0);
3821 }
3822
3823 fesetround(save_round_mode);
3824
3825 END (rint_tonearest);
3826 }
3827
3828 static void
3829 rint_test_towardzero (void)
3830 {
3831 int save_round_mode;
3832 START (rint_towardzero);
3833
3834 save_round_mode = fegetround();
3835
3836 if (!fesetround (FE_TOWARDZERO))
3837 {
3838 TEST_f_f (rint, 2.0, 2.0);
3839 TEST_f_f (rint, 1.5, 1.0);
3840 TEST_f_f (rint, 1.0, 1.0);
3841 TEST_f_f (rint, 0.5, 0.0);
3842 TEST_f_f (rint, 0.0, 0.0);
3843 TEST_f_f (rint, minus_zero, minus_zero);
3844 TEST_f_f (rint, -0.5, -0.0);
3845 TEST_f_f (rint, -1.0, -1.0);
3846 TEST_f_f (rint, -1.5, -1.0);
3847 TEST_f_f (rint, -2.0, -2.0);
3848 }
3849
3850 fesetround(save_round_mode);
3851
3852 END (rint_towardzero);
3853 }
3854
3855 static void
3856 rint_test_downward (void)
3857 {
3858 int save_round_mode;
3859 START (rint_downward);
3860
3861 save_round_mode = fegetround();
3862
3863 if (!fesetround (FE_DOWNWARD))
3864 {
3865 TEST_f_f (rint, 2.0, 2.0);
3866 TEST_f_f (rint, 1.5, 1.0);
3867 TEST_f_f (rint, 1.0, 1.0);
3868 TEST_f_f (rint, 0.5, 0.0);
3869 TEST_f_f (rint, 0.0, 0.0);
3870 TEST_f_f (rint, minus_zero, minus_zero);
3871 TEST_f_f (rint, -0.5, -1.0);
3872 TEST_f_f (rint, -1.0, -1.0);
3873 TEST_f_f (rint, -1.5, -2.0);
3874 TEST_f_f (rint, -2.0, -2.0);
3875 }
3876
3877 fesetround(save_round_mode);
3878
3879 END (rint_downward);
3880 }
3881
3882 static void
3883 rint_test_upward (void)
3884 {
3885 int save_round_mode;
3886 START (rint_upward);
3887
3888 save_round_mode = fegetround();
3889
3890 if (!fesetround (FE_UPWARD))
3891 {
3892 TEST_f_f (rint, 2.0, 2.0);
3893 TEST_f_f (rint, 1.5, 2.0);
3894 TEST_f_f (rint, 1.0, 1.0);
3895 TEST_f_f (rint, 0.5, 1.0);
3896 TEST_f_f (rint, 0.0, 0.0);
3897 TEST_f_f (rint, minus_zero, minus_zero);
3898 TEST_f_f (rint, -0.5, -0.0);
3899 TEST_f_f (rint, -1.0, -1.0);
3900 TEST_f_f (rint, -1.5, -1.0);
3901 TEST_f_f (rint, -2.0, -2.0);
3902 }
3903
3904 fesetround(save_round_mode);
3905
3906 END (rint_upward);
3907 }
3908
3909 static void
3910 round_test (void)
3911 {
3912 START (round);
3913
3914 TEST_f_f (round, 0, 0);
3915 TEST_f_f (round, minus_zero, minus_zero);
3916 TEST_f_f (round, 0.2L, 0.0);
3917 TEST_f_f (round, -0.2L, minus_zero);
3918 TEST_f_f (round, 0.5, 1.0);
3919 TEST_f_f (round, -0.5, -1.0);
3920 TEST_f_f (round, 0.8L, 1.0);
3921 TEST_f_f (round, -0.8L, -1.0);
3922 TEST_f_f (round, 1.5, 2.0);
3923 TEST_f_f (round, -1.5, -2.0);
3924 TEST_f_f (round, 2097152.5, 2097153);
3925 TEST_f_f (round, -2097152.5, -2097153);
3926
3927 END (round);
3928 }
3929
3930
3931 static void
3932 scalb_test (void)
3933 {
3934
3935 START (scalb);
3936
3937 TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
3938 TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
3939
3940 TEST_ff_f (scalb, 0, nan_value, nan_value);
3941 TEST_ff_f (scalb, 1, nan_value, nan_value);
3942
3943 TEST_ff_f (scalb, 1, 0, 1);
3944 TEST_ff_f (scalb, -1, 0, -1);
3945
3946 TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
3947 TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
3948
3949 TEST_ff_f (scalb, 0, 2, 0);
3950 TEST_ff_f (scalb, minus_zero, -4, minus_zero);
3951 TEST_ff_f (scalb, 0, 0, 0);
3952 TEST_ff_f (scalb, minus_zero, 0, minus_zero);
3953 TEST_ff_f (scalb, 0, -1, 0);
3954 TEST_ff_f (scalb, minus_zero, -10, minus_zero);
3955 TEST_ff_f (scalb, 0, minus_infty, 0);
3956 TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
3957
3958 TEST_ff_f (scalb, plus_infty, -1, plus_infty);
3959 TEST_ff_f (scalb, minus_infty, -10, minus_infty);
3960 TEST_ff_f (scalb, plus_infty, 0, plus_infty);
3961 TEST_ff_f (scalb, minus_infty, 0, minus_infty);
3962 TEST_ff_f (scalb, plus_infty, 2, plus_infty);
3963 TEST_ff_f (scalb, minus_infty, 100, minus_infty);
3964
3965 TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
3966 TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
3967
3968 TEST_ff_f (scalb, 1, plus_infty, plus_infty);
3969 TEST_ff_f (scalb, -1, plus_infty, minus_infty);
3970 TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
3971 TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
3972
3973 TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3974 TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3975
3976 TEST_ff_f (scalb, nan_value, 1, nan_value);
3977 TEST_ff_f (scalb, 1, nan_value, nan_value);
3978 TEST_ff_f (scalb, nan_value, 0, nan_value);
3979 TEST_ff_f (scalb, 0, nan_value, nan_value);
3980 TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
3981 TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
3982 TEST_ff_f (scalb, nan_value, nan_value, nan_value);
3983
3984 TEST_ff_f (scalb, 0.8L, 4, 12.8L);
3985 TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
3986
3987 END (scalb);
3988 }
3989
3990
3991 static void
3992 scalbn_test (void)
3993 {
3994
3995 START (scalbn);
3996
3997 TEST_fi_f (scalbn, 0, 0, 0);
3998 TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
3999
4000 TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
4001 TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
4002 TEST_fi_f (scalbn, nan_value, 1, nan_value);
4003
4004 TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
4005 TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
4006
4007 TEST_fi_f (scalbn, 1, 0L, 1);
4008
4009 END (scalbn);
4010 }
4011
4012
4013 static void
4014 scalbln_test (void)
4015 {
4016
4017 START (scalbln);
4018
4019 TEST_fl_f (scalbln, 0, 0, 0);
4020 TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
4021
4022 TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
4023 TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
4024 TEST_fl_f (scalbln, nan_value, 1, nan_value);
4025
4026 TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
4027 TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
4028
4029 TEST_fl_f (scalbln, 1, 0L, 1);
4030
4031 END (scalbn);
4032 }
4033
4034
4035 static void
4036 signbit_test (void)
4037 {
4038
4039 START (signbit);
4040
4041 TEST_f_b (signbit, 0, 0);
4042 TEST_f_b (signbit, minus_zero, 1);
4043 TEST_f_b (signbit, plus_infty, 0);
4044 TEST_f_b (signbit, minus_infty, 1);
4045
4046 /* signbit (x) != 0 for x < 0. */
4047 TEST_f_b (signbit, -1, 1);
4048 /* signbit (x) == 0 for x >= 0. */
4049 TEST_f_b (signbit, 1, 0);
4050
4051 END (signbit);
4052 }
4053
4054
4055 static void
4056 sin_test (void)
4057 {
4058 errno = 0;
4059 FUNC(sin) (0);
4060 if (errno == ENOSYS)
4061 /* Function not implemented. */
4062 return;
4063
4064 START (sin);
4065
4066 TEST_f_f (sin, 0, 0);
4067 TEST_f_f (sin, minus_zero, minus_zero);
4068 TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
4069 TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
4070 TEST_f_f (sin, nan_value, nan_value);
4071
4072 TEST_f_f (sin, M_PI_6l, 0.5);
4073 TEST_f_f (sin, -M_PI_6l, -0.5);
4074 TEST_f_f (sin, M_PI_2l, 1);
4075 TEST_f_f (sin, -M_PI_2l, -1);
4076 TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
4077
4078 #ifdef TEST_DOUBLE
4079 TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
4080 #endif
4081
4082 END (sin);
4083
4084 }
4085
4086
4087 static void
4088 sincos_test (void)
4089 {
4090 FLOAT sin_res, cos_res;
4091
4092 errno = 0;
4093 FUNC(sincos) (0, &sin_res, &cos_res);
4094 if (errno == ENOSYS)
4095 /* Function not implemented. */
4096 return;
4097
4098 START (sincos);
4099
4100 /* sincos is treated differently because it returns void. */
4101 TEST_extra (sincos, 0, 0, 1);
4102
4103 TEST_extra (sincos, minus_zero, minus_zero, 1);
4104 TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4105 TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4106 TEST_extra (sincos, nan_value, nan_value, nan_value);
4107
4108 TEST_extra (sincos, M_PI_2l, 1, 0);
4109 TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
4110 TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
4111 TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
4112
4113 #ifdef TEST_DOUBLE
4114 TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
4115 #endif
4116
4117 END (sincos);
4118 }
4119
4120 static void
4121 sinh_test (void)
4122 {
4123 errno = 0;
4124 FUNC(sinh) (0.7L);
4125 if (errno == ENOSYS)
4126 /* Function not implemented. */
4127 return;
4128
4129 START (sinh);
4130 TEST_f_f (sinh, 0, 0);
4131 TEST_f_f (sinh, minus_zero, minus_zero);
4132
4133 #ifndef TEST_INLINE
4134 TEST_f_f (sinh, plus_infty, plus_infty);
4135 TEST_f_f (sinh, minus_infty, minus_infty);
4136 #endif
4137 TEST_f_f (sinh, nan_value, nan_value);
4138
4139 TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
4140 TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
4141
4142 END (sinh);
4143 }
4144
4145 static void
4146 sqrt_test (void)
4147 {
4148 errno = 0;
4149 FUNC(sqrt) (1);
4150 if (errno == ENOSYS)
4151 /* Function not implemented. */
4152 return;
4153
4154 START (sqrt);
4155
4156 TEST_f_f (sqrt, 0, 0);
4157 TEST_f_f (sqrt, nan_value, nan_value);
4158 TEST_f_f (sqrt, plus_infty, plus_infty);
4159
4160 TEST_f_f (sqrt, minus_zero, minus_zero);
4161
4162 /* sqrt (x) == NaN plus invalid exception for x < 0. */
4163 TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
4164 TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
4165 TEST_f_f (sqrt, nan_value, nan_value);
4166
4167 TEST_f_f (sqrt, 2209, 47);
4168 TEST_f_f (sqrt, 4, 2);
4169 TEST_f_f (sqrt, 2, M_SQRT2l);
4170 TEST_f_f (sqrt, 0.25, 0.5);
4171 TEST_f_f (sqrt, 6642.25, 81.5);
4172 TEST_f_f (sqrt, 15190.5625L, 123.25L);
4173 TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
4174
4175 END (sqrt);
4176 }
4177
4178
4179 static void
4180 tan_test (void)
4181 {
4182 errno = 0;
4183 FUNC(tan) (0);
4184 if (errno == ENOSYS)
4185 /* Function not implemented. */
4186 return;
4187
4188 START (tan);
4189
4190 TEST_f_f (tan, 0, 0);
4191 TEST_f_f (tan, minus_zero, minus_zero);
4192 TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
4193 TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
4194 TEST_f_f (tan, nan_value, nan_value);
4195
4196 TEST_f_f (tan, M_PI_4l, 1);
4197 TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
4198
4199 END (tan);
4200 }
4201
4202 static void
4203 tanh_test (void)
4204 {
4205 errno = 0;
4206 FUNC(tanh) (0.7L);
4207 if (errno == ENOSYS)
4208 /* Function not implemented. */
4209 return;
4210
4211 START (tanh);
4212
4213 TEST_f_f (tanh, 0, 0);
4214 TEST_f_f (tanh, minus_zero, minus_zero);
4215
4216 #ifndef TEST_INLINE
4217 TEST_f_f (tanh, plus_infty, 1);
4218 TEST_f_f (tanh, minus_infty, -1);
4219 #endif
4220 TEST_f_f (tanh, nan_value, nan_value);
4221
4222 TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
4223 TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
4224
4225 TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
4226 TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
4227
4228 /* 2^-57 */
4229 TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
4230
4231 END (tanh);
4232 }
4233
4234 static void
4235 tgamma_test (void)
4236 {
4237 errno = 0;
4238 FUNC(tgamma) (1);
4239 if (errno == ENOSYS)
4240 /* Function not implemented. */
4241 return;
4242 feclearexcept (FE_ALL_EXCEPT);
4243
4244 START (tgamma);
4245
4246 TEST_f_f (tgamma, plus_infty, plus_infty);
4247 TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4248 TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4249 /* tgamma (x) == NaN plus invalid exception for integer x <= 0. */
4250 TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
4251 TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
4252 TEST_f_f (tgamma, nan_value, nan_value);
4253
4254 TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
4255 TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
4256
4257 TEST_f_f (tgamma, 1, 1);
4258 TEST_f_f (tgamma, 4, 6);
4259
4260 TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
4261 TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
4262
4263 END (tgamma);
4264 }
4265
4266
4267 static void
4268 trunc_test (void)
4269 {
4270 START (trunc);
4271
4272 TEST_f_f (trunc, plus_infty, plus_infty);
4273 TEST_f_f (trunc, minus_infty, minus_infty);
4274 TEST_f_f (trunc, nan_value, nan_value);
4275
4276 TEST_f_f (trunc, 0, 0);
4277 TEST_f_f (trunc, minus_zero, minus_zero);
4278 TEST_f_f (trunc, 0.625, 0);
4279 TEST_f_f (trunc, -0.625, minus_zero);
4280 TEST_f_f (trunc, 1, 1);
4281 TEST_f_f (trunc, -1, -1);
4282 TEST_f_f (trunc, 1.625, 1);
4283 TEST_f_f (trunc, -1.625, -1);
4284
4285 TEST_f_f (trunc, 1048580.625L, 1048580L);
4286 TEST_f_f (trunc, -1048580.625L, -1048580L);
4287
4288 TEST_f_f (trunc, 8388610.125L, 8388610.0L);
4289 TEST_f_f (trunc, -8388610.125L, -8388610.0L);
4290
4291 TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
4292 TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
4293
4294
4295 END (trunc);
4296 }
4297
4298 static void
4299 y0_test (void)
4300 {
4301 FLOAT s, c;
4302 errno = 0;
4303 FUNC (sincos) (0, &s, &c);
4304 if (errno == ENOSYS)
4305 /* Required function not implemented. */
4306 return;
4307 FUNC(y0) (1);
4308 if (errno == ENOSYS)
4309 /* Function not implemented. */
4310 return;
4311
4312 /* y0 is the Bessel function of the second kind of order 0 */
4313 START (y0);
4314
4315 TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
4316 TEST_f_f (y0, 0.0, minus_infty);
4317 TEST_f_f (y0, nan_value, nan_value);
4318 TEST_f_f (y0, plus_infty, 0);
4319
4320 TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
4321 TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
4322 TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
4323 TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
4324 TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
4325 TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
4326 TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
4327
4328 END (y0);
4329 }
4330
4331
4332 static void
4333 y1_test (void)
4334 {
4335 FLOAT s, c;
4336 errno = 0;
4337 FUNC (sincos) (0, &s, &c);
4338 if (errno == ENOSYS)
4339 /* Required function not implemented. */
4340 return;
4341 FUNC(y1) (1);
4342 if (errno == ENOSYS)
4343 /* Function not implemented. */
4344 return;
4345
4346 /* y1 is the Bessel function of the second kind of order 1 */
4347 START (y1);
4348
4349 TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
4350 TEST_f_f (y1, 0.0, minus_infty);
4351 TEST_f_f (y1, plus_infty, 0);
4352 TEST_f_f (y1, nan_value, nan_value);
4353
4354 TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
4355 TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
4356 TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
4357 TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
4358 TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
4359 TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
4360 TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
4361
4362 END (y1);
4363 }
4364
4365
4366 static void
4367 yn_test (void)
4368 {
4369 FLOAT s, c;
4370 errno = 0;
4371 FUNC (sincos) (0, &s, &c);
4372 if (errno == ENOSYS)
4373 /* Required function not implemented. */
4374 return;
4375 FUNC(yn) (1, 1);
4376 if (errno == ENOSYS)
4377 /* Function not implemented. */
4378 return;
4379
4380 /* yn is the Bessel function of the second kind of order n */
4381 START (yn);
4382
4383 /* yn (0, x) == y0 (x) */
4384 TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
4385 TEST_ff_f (yn, 0, 0.0, minus_infty);
4386 TEST_ff_f (yn, 0, nan_value, nan_value);
4387 TEST_ff_f (yn, 0, plus_infty, 0);
4388
4389 TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
4390 TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
4391 TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
4392 TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
4393 TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
4394 TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
4395 TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
4396
4397 /* yn (1, x) == y1 (x) */
4398 TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
4399 TEST_ff_f (yn, 1, 0.0, minus_infty);
4400 TEST_ff_f (yn, 1, plus_infty, 0);
4401 TEST_ff_f (yn, 1, nan_value, nan_value);
4402
4403 TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
4404 TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
4405 TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
4406 TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
4407 TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
4408 TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
4409 TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
4410
4411 /* yn (3, x) */
4412 TEST_ff_f (yn, 3, plus_infty, 0);
4413 TEST_ff_f (yn, 3, nan_value, nan_value);
4414
4415 TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
4416 TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
4417 TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
4418 TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
4419 TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
4420
4421 /* yn (10, x) */
4422 TEST_ff_f (yn, 10, plus_infty, 0);
4423 TEST_ff_f (yn, 10, nan_value, nan_value);
4424
4425 TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
4426 TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
4427 TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
4428 TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
4429 TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
4430
4431 END (yn);
4432
4433 }
4434
4435
4436 static void
4437 significand_test (void)
4438 {
4439 /* significand returns the mantissa of the exponential representation. */
4440 START (significand);
4441
4442 TEST_f_f (significand, 4.0, 1.0);
4443 TEST_f_f (significand, 6.0, 1.5);
4444 TEST_f_f (significand, 8.0, 1.0);
4445
4446 END (significand);
4447 }
4448
4449
4450 static void
4451 initialize (void)
4452 {
4453 fpstack_test ("start *init*");
4454 plus_zero = 0.0;
4455 nan_value = plus_zero / plus_zero; /* Suppress GCC warning */
4456
4457 minus_zero = FUNC(copysign) (0.0, -1.0);
4458 plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
4459 HUGE_VALL, HUGE_VAL, HUGE_VALF);
4460 minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
4461 -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
4462 max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4463 LDBL_MAX, DBL_MAX, FLT_MAX);
4464 min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
4465 LDBL_MIN, DBL_MIN, FLT_MIN);
4466
4467 (void) &plus_zero;
4468 (void) &nan_value;
4469 (void) &minus_zero;
4470 (void) &plus_infty;
4471 (void) &minus_infty;
4472 (void) &max_value;
4473 (void) &min_value;
4474
4475 /* Clear all exceptions. From now on we must not get random exceptions. */
4476 feclearexcept (FE_ALL_EXCEPT);
4477
4478 /* Test to make sure we start correctly. */
4479 fpstack_test ("end *init*");
4480 }
4481
4482 /* Definitions of arguments for argp functions. */
4483 static const struct argp_option options[] =
4484 {
4485 { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
4486 { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
4487 { "no-max-error", 'f', NULL, 0,
4488 "Don't output maximal errors of functions"},
4489 { "no-points", 'p', NULL, 0,
4490 "Don't output results of functions invocations"},
4491 { "ignore-max-ulp", 'i', "yes/no", 0,
4492 "Ignore given maximal errors"},
4493 { NULL, 0, NULL, 0, NULL }
4494 };
4495
4496 /* Short description of program. */
4497 static const char doc[] = "Math test suite: " TEST_MSG ;
4498
4499 /* Prototype for option handler. */
4500 static error_t parse_opt (int key, char *arg, struct argp_state *state);
4501
4502 /* Data structure to communicate with argp functions. */
4503 static struct argp argp =
4504 {
4505 options, parse_opt, NULL, doc,
4506 };
4507
4508
4509 /* Handle program arguments. */
4510 static error_t
4511 parse_opt (int key, char *arg, struct argp_state *state)
4512 {
4513 switch (key)
4514 {
4515 case 'f':
4516 output_max_error = 0;
4517 break;
4518 case 'i':
4519 if (strcmp (arg, "yes") == 0)
4520 ignore_max_ulp = 1;
4521 else if (strcmp (arg, "no") == 0)
4522 ignore_max_ulp = 0;
4523 break;
4524 case 'p':
4525 output_points = 0;
4526 break;
4527 case 'u':
4528 output_ulps = 1;
4529 break;
4530 case 'v':
4531 if (optarg)
4532 verbose = (unsigned int) strtoul (optarg, NULL, 0);
4533 else
4534 verbose = 3;
4535 break;
4536 default:
4537 return ARGP_ERR_UNKNOWN;
4538 }
4539 return 0;
4540 }
4541
4542 #if 0
4543 /* function to check our ulp calculation. */
4544 void
4545 check_ulp (void)
4546 {
4547 int i;
4548
4549 FLOAT u, diff, ulp;
4550 /* This gives one ulp. */
4551 u = FUNC(nextafter) (10, 20);
4552 check_equal (10.0, u, 1, &diff, &ulp);
4553 printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
4554
4555 /* This gives one more ulp. */
4556 u = FUNC(nextafter) (u, 20);
4557 check_equal (10.0, u, 2, &diff, &ulp);
4558 printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
4559
4560 /* And now calculate 100 ulp. */
4561 for (i = 2; i < 100; i++)
4562 u = FUNC(nextafter) (u, 20);
4563 check_equal (10.0, u, 100, &diff, &ulp);
4564 printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
4565 }
4566 #endif
4567
4568 int
4569 main (int argc, char **argv)
4570 {
4571
4572 int remaining;
4573
4574 verbose = 1;
4575 output_ulps = 0;
4576 output_max_error = 1;
4577 output_points = 1;
4578 /* XXX set to 0 for releases. */
4579 ignore_max_ulp = 0;
4580
4581 /* Parse and process arguments. */
4582 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
4583
4584 if (remaining != argc)
4585 {
4586 fprintf (stderr, "wrong number of arguments");
4587 argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
4588 exit (EXIT_FAILURE);
4589 }
4590
4591 if (output_ulps)
4592 {
4593 ulps_file = fopen ("ULPs", "a");
4594 if (ulps_file == NULL)
4595 {
4596 perror ("can't open file `ULPs' for writing: ");
4597 exit (1);
4598 }
4599 }
4600
4601
4602 initialize ();
4603 printf (TEST_MSG);
4604
4605 #if 0
4606 check_ulp ();
4607 #endif
4608
4609 /* Keep the tests a wee bit ordered (according to ISO C99). */
4610 /* Classification macros: */
4611 fpclassify_test ();
4612 isfinite_test ();
4613 isnormal_test ();
4614 signbit_test ();
4615
4616 /* Trigonometric functions: */
4617 acos_test ();
4618 asin_test ();
4619 atan_test ();
4620 atan2_test ();
4621 cos_test ();
4622 sin_test ();
4623 sincos_test ();
4624 tan_test ();
4625
4626 /* Hyperbolic functions: */
4627 acosh_test ();
4628 asinh_test ();
4629 atanh_test ();
4630 cosh_test ();
4631 sinh_test ();
4632 tanh_test ();
4633
4634 /* Exponential and logarithmic functions: */
4635 exp_test ();
4636 exp10_test ();
4637 exp2_test ();
4638 expm1_test ();
4639 frexp_test ();
4640 ldexp_test ();
4641 log_test ();
4642 log10_test ();
4643 log1p_test ();
4644 log2_test ();
4645 logb_test ();
4646 modf_test ();
4647 ilogb_test ();
4648 scalb_test ();
4649 scalbn_test ();
4650 scalbln_test ();
4651 significand_test ();
4652
4653 /* Power and absolute value functions: */
4654 cbrt_test ();
4655 fabs_test ();
4656 hypot_test ();
4657 pow_test ();
4658 sqrt_test ();
4659
4660 /* Error and gamma functions: */
4661 erf_test ();
4662 erfc_test ();
4663 gamma_test ();
4664 lgamma_test ();
4665 tgamma_test ();
4666
4667 /* Nearest integer functions: */
4668 ceil_test ();
4669 floor_test ();
4670 nearbyint_test ();
4671 rint_test ();
4672 rint_test_tonearest ();
4673 rint_test_towardzero ();
4674 rint_test_downward ();
4675 rint_test_upward ();
4676 lrint_test ();
4677 llrint_test ();
4678 round_test ();
4679 lround_test ();
4680 llround_test ();
4681 trunc_test ();
4682
4683 /* Remainder functions: */
4684 fmod_test ();
4685 remainder_test ();
4686 remquo_test ();
4687
4688 /* Manipulation functions: */
4689 copysign_test ();
4690 nextafter_test ();
4691 nexttoward_test ();
4692
4693 /* maximum, minimum and positive difference functions */
4694 fdim_test ();
4695 fmax_test ();
4696 fmin_test ();
4697
4698 /* Multiply and add: */
4699 fma_test ();
4700
4701 /* Complex functions: */
4702 cabs_test ();
4703 cacos_test ();
4704 cacosh_test ();
4705 carg_test ();
4706 casin_test ();
4707 casinh_test ();
4708 catan_test ();
4709 catanh_test ();
4710 ccos_test ();
4711 ccosh_test ();
4712 cexp_test ();
4713 cimag_test ();
4714 clog10_test ();
4715 clog_test ();
4716 conj_test ();
4717 cpow_test ();
4718 cproj_test ();
4719 creal_test ();
4720 csin_test ();
4721 csinh_test ();
4722 csqrt_test ();
4723 ctan_test ();
4724 ctanh_test ();
4725
4726 /* Bessel functions: */
4727 j0_test ();
4728 j1_test ();
4729 jn_test ();
4730 y0_test ();
4731 y1_test ();
4732 yn_test ();
4733
4734 if (output_ulps)
4735 fclose (ulps_file);
4736
4737 printf ("\nTest suite completed:\n");
4738 printf (" %d test cases plus %d tests for exception flags executed.\n",
4739 noTests, noExcTests);
4740 if (noXFails)
4741 printf (" %d expected failures occurred.\n", noXFails);
4742 if (noXPasses)
4743 printf (" %d unexpected passes occurred.\n", noXPasses);
4744 if (noErrors)
4745 {
4746 printf (" %d errors occurred.\n", noErrors);
4747 return 1;
4748 }
4749 printf (" All tests passed successfully.\n");
4750
4751 return 0;
4752 }
4753
4754 /*
4755 * Local Variables:
4756 * mode:c
4757 * End:
4758 */
A mirror of the official glibc repository