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