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