Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

libm-test.inc

Visit:

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

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

Download in other formats:

Original Format