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