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