Context Navigation

libm-test.inc

Visit:

Last change on this file was 2158, checked in by bird, 20 years ago
math, malloc suchlike.
Property cvs2svn:cvs-rev set to `1.2` Property svn:eol-style set to `native` Property svn:executable set to ``* Property svn:keywords set to `Author Date Id Revision`
File size: 141.9 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format