Blame - ap/build/uClibc/test/math/libm-test.inc - T106_DC

blob: 59555669b3c5ef5079cb0357fccd89c2ab82fc14 [file] [log] [blame]

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