[thirdparty/glibc.git] / math / tgmath.h

/* Copyright (C) 1997 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/*
 *	ISO C 9X Standard: 7.9 Type-generic math	<tgmath.h>
 */

#ifndef _TGMATH_H
#define _TGMATH_H	1

/* Include the needed headers.  */
#include <math.h>
#include <complex.h>


/* Since `complex' is currently not really implemented in most C compilers
   and if it is implemented, the implementations differ.  This makes it
   quite difficult to write a generic implementation of this header.  We
   do not try this for now and instead concentrate only on GNU CC.  Once
   we have more information support for other compilers might follow.  */

#if defined __GNUC__ && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7)

/* We have two kinds of generic macros: to support functions which are
   only defined on real valued parameters and those which are defined
   for complex functions as well.  */
# define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \
     (__extension__ (sizeof (__real__ (Val)) == sizeof (long double)	      \
		     ? Fct##l (Val)					      \
		     : (sizeof (__real__ (Val)) == sizeof (double)	      \
			? Fct (Val)					      \
			: Fct##f (Val))))

# define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \
     (__extension__ (sizeof (__real__ (Val1)) == sizeof (long double)	      \
		     ? Fct##l (Val1, Val2)				      \
		     : (sizeof (__real__ (Val1)) == sizeof (double)	      \
			? Fct (Val1, Val2)				      \
			: Fct##f (Val1, Val2))))

# define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \
     (__extension__ (sizeof (Val1) == sizeof (long double)		      \
		     || sizeof (Val2) == sizeof (long double)		      \
		     ? Fct##l (Val1, Val2)				      \
		     : (sizeof (Val1) == sizeof (double)		      \
			|| sizeof (Val2) == sizeof (double)		      \
			? Fct (Val1, Val2)				      \
			: Fct##f (Val1, Val2))))

# define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
     (__extension__ (sizeof (Val1) == sizeof (long double)		      \
		     || sizeof (Val2) == sizeof (long double)		      \
		     ? Fct##l (Val1, Val2, Val3)			      \
		     : (sizeof (Val1) == sizeof (double)		      \
			|| sizeof (Val2) == sizeof (double)		      \
			? Fct (Val1, Val2, Val3)			      \
			: Fct##f (Val1, Val2, Val3))))

# define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \
     (__extension__ (sizeof (__real__ (Val)) == sizeof (long double)	      \
		     ? (sizeof (__real__ (Val)) == sizeof (Val)		      \
			? Fct##l (Val)					      \
			: Cfct##l (Val))				      \
		     : (sizeof (__real__ (Val)) == sizeof (double)	      \
			? (sizeof (__real__ (Val)) == sizeof (Val)	      \
			   ? Fct (Val)					      \
			   : Cfct (Val))				      \
			: (sizeof (__real__ (Val)) == sizeof (Val)	      \
			   ? Fct##f (Val)				      \
			   : Cfct##f (Val)))))

# define __TGMATH_UNARY_IMAG_ONLY(Val, Fct) \
     (__extension__ (sizeof (Val) == sizeof (__complex__ long double)	      \
		     ? Fct##l (Val)					      \
		     : (sizeof (Val) == sizeof (__complex__ double)	      \
			? Fct (Val)					      \
			: Fct##f (Val))))

# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
     (__extension__ (sizeof (__real__ (Val1)) == sizeof (long double)	      \
		     || sizeof (__real__ (Val2)) == sizeof (long double)      \
		     ? (sizeof (__real__ (Val1)) == sizeof (Val1)	      \
			&& sizeof (__real__ (Val2)) == sizeof (Val2)	      \
			? Fct##l (Val1, Val2)				      \
			: Cfct##l (Val1, Val2))				      \
		     : (sizeof (__real__ (Val1)) == sizeof (double)	      \
			|| sizeof (__real__ (Val2)) == sizeof (double)	      \
			? (sizeof (__real__ (Val1)) == sizeof (Val1)	      \
			   && sizeof (__real__ (Val2)) == sizeof (Val2)	      \
			   ? Fct (Val1, Val2)				      \
			   : Cfct (Val1, Val2))				      \
			: (sizeof (__real__ (Val1)) == sizeof (Val1)	      \
			   && sizeof (__real__ (Val2)) == sizeof (Val2)	      \
			   ? Fct##f (Val1, Val2)			      \
			   : Cfct##f (Val1, Val2)))))
#else
# error "Unsupported compiler; you cannot use <tgmath.h>"
#endif


/* Unary functions defined for real and complex values.  */


/* Trigonometric functions.  */

/* Arc cosine of X.  */
#define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos)
/* Arc sine of X.  */
#define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin)
/* Arc tangent of X.  */
#define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan)
/* Arc tangent of Y/X.  */
#define atan2(Val) __TGMATH_UNARY_REAL_ONLY (Val, atan2)

/* Cosine of X.  */
#define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos)
/* Sine of X.  */
#define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin)
/* Tangent of X.  */
#define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan)


/* Hyperbolic functions.  */

/* Hyperbolic arc cosine of X.  */
#define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh)
/* Hyperbolic arc sine of X.  */
#define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh)
/* Hyperbolic arc tangent of X.  */
#define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh)

/* Hyperbolic cosine of X.  */
#define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh)
/* Hyperbolic sine of X.  */
#define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh)
/* Hyperbolic tangent of X.  */
#define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh)


/* Exponential and logarithmic functions.  */

/* Exponential function of X.  */
#define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp)

/* Break VALUE into a normalized fraction and an integral power of 2.  */
#define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp)

/* X times (two to the EXP power).  */
#define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp)

/* Natural logarithm of X.  */
#define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog)

/* Base-ten logarithm of X.  */
#define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, __clog10)

/* Return exp(X) - 1.  */
#define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1)

/* Return log(1 + X).  */
#define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p)

/* Return the base 2 signed integral exponent of X.  */
#define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb)

/* Compute base-2 exponential of X.  */
#define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2)

/* Compute base-2 logarithm of X.  */
#define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)


/* Power functions.  */

/* Return X to the Y power.  */
#define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)

/* Return the square root of X.  */
#define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt)

/* Return `sqrt(X*X + Y*Y)'.  */
#define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot)

/* Return the cube root of X.  */
#define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt)


/* Nearest integer, absolute value, and remainder functions.  */

/* Smallest integral value not less than X.  */
#define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil)

/* Absolute value of X.  */
#define fabs(Val) __TGMATH_UNARY_REAL_IMAG (Val, fabs, cabs)

/* Largest integer not greater than X.  */
#define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor)

/* Floating-point modulo remainder of X/Y.  */
#define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod)

/* Round X to integral valuein floating-point format using current
   rounding direction, but do not raise inexact exception.  */
#define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint)

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
#define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round)

/* Round X to the integral value in floating-point format nearest but
   not larger in magnitude.  */
#define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc)

/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
   and magnitude congruent `mod 2^n' to the magnitude of the integral
   quotient x/y, with n >= 3.  */
#define remquo(Val1, Val2, Val3) \
     __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo)

/* Round X to nearest integral value according to current rounding
   direction.  */
#define lrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, lrint)
#define llrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, llrint)

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
#define lround(Val) __TGMATH_UNARY_REAL_ONLY (Val, lround)
#define llround(Val) __TGMATH_UNARY_REAL_ONLY (Val, llround)


/* Return X with its signed changed to Y's.  */
#define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign)

/* Error and gamma functions.  */
#define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf)
#define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc)
#define gamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, gamma)
#define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma)


/* Return the integer nearest X in the direction of the
   prevailing rounding mode.  */
#define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)

/* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
#define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter)
#define nextafterx(Val1, Val2) \
     __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, nextafterx)

/* Return the remainder of integer divison X / Y with infinite precision.  */
#define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder)

/* Return X times (2 to the Nth power).  */
#define scalb(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, scalb)

/* Return X times (2 to the Nth power).  */
#define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn)

/* Return X times (2 to the Nth power).  */
#define scalbln(Val1, Val2) \
     __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln)

/* Return the binary exponent of X, which must be nonzero.  */
#define ilogb(Val) __TGMATH_UNARY_REAL_ONLY (Val, ilogb)


/* Return positive difference between X and Y.  */
#define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)

/* Return maximum numeric value from X and Y.  */
#define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax)

/* Return minimum numeric value from X and Y.  */
#define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin)


/* Absolute value, conjugates, and projection.  */

/* Argument value of Z.  */
#define carg(Val) __TGMATH_UNARY_IMAG_ONLY (Val, carg)

/* Complex conjugate of Z.  */
#define conj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, conj)

/* Projection of Z onto the Riemann sphere.  */
#define cproj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cproj)


/* Decomposing complex values.  */

/* Imaginary part of Z.  */
#define cimag(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cimag)

/* Real part of Z.  */
#define creal(Val) __TGMATH_UNARY_IMAG_ONLY (Val, creal)

#endif /* tgmath.h */
Commit	Line	Data
dfd2257a UD	1	/* Copyright (C) 1997 Free Software Foundation, Inc.
	2	This file is part of the GNU C Library.
	3
	4	The GNU C Library is free software; you can redistribute it and/or
	5	modify it under the terms of the GNU Library General Public License as
	6	published by the Free Software Foundation; either version 2 of the
	7	License, or (at your option) any later version.
	8
	9	The GNU C Library is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	Library General Public License for more details.
	13
	14	You should have received a copy of the GNU Library General Public
	15	License along with the GNU C Library; see the file COPYING.LIB. If not,
	16	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	17	Boston, MA 02111-1307, USA. */
	18
	19	/*
	20	* ISO C 9X Standard: 7.9 Type-generic math <tgmath.h>
	21	*/
	22
	23	#ifndef _TGMATH_H
	24	#define _TGMATH_H 1
	25
	26	/* Include the needed headers. */
	27	#include <math.h>
	28	#include <complex.h>
	29
	30
	31	/* Since `complex' is currently not really implemented in most C compilers
	32	and if it is implemented, the implementations differ. This makes it
	33	quite difficult to write a generic implementation of this header. We
	34	do not try this for now and instead concentrate only on GNU CC. Once
	35	we have more information support for other compilers might follow. */
	36
	37	#if defined __GNUC__ && (__GNUC__ > 2 \|\| __GNUC__ == 2 && __GNUC_MINOR__ >= 7)
	38
	39	/* We have two kinds of generic macros: to support functions which are
	40	only defined on real valued parameters and those which are defined
	41	for complex functions as well. */
	42	# define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \
	43	(__extension__ (sizeof (__real__ (Val)) == sizeof (long double) \
	44	? Fct##l (Val) \
	45	: (sizeof (__real__ (Val)) == sizeof (double) \
	46	? Fct (Val) \
	47	: Fct##f (Val))))
	48
	49	# define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \
	50	(__extension__ (sizeof (__real__ (Val1)) == sizeof (long double) \
	51	? Fct##l (Val1, Val2) \
	52	: (sizeof (__real__ (Val1)) == sizeof (double) \
	53	? Fct (Val1, Val2) \
	54	: Fct##f (Val1, Val2))))
	55
	56	# define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \
	57	(__extension__ (sizeof (Val1) == sizeof (long double) \
	58	\|\| sizeof (Val2) == sizeof (long double) \
	59	? Fct##l (Val1, Val2) \
	60	: (sizeof (Val1) == sizeof (double) \
	61	\|\| sizeof (Val2) == sizeof (double) \
	62	? Fct (Val1, Val2) \
	63	: Fct##f (Val1, Val2))))
	64
65	# define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
66	(__extension__ (sizeof (Val1) == sizeof (long double) \
67	\|\| sizeof (Val2) == sizeof (long double) \
68	? Fct##l (Val1, Val2, Val3) \
69	: (sizeof (Val1) == sizeof (double) \
70	\|\| sizeof (Val2) == sizeof (double) \
71	? Fct (Val1, Val2, Val3) \
72	: Fct##f (Val1, Val2, Val3))))
73
74	# define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \
75	(__extension__ (sizeof (__real__ (Val)) == sizeof (long double) \
76	? (sizeof (__real__ (Val)) == sizeof (Val) \
77	? Fct##l (Val) \
78	: Cfct##l (Val)) \
79	: (sizeof (__real__ (Val)) == sizeof (double) \
80	? (sizeof (__real__ (Val)) == sizeof (Val) \
81	? Fct (Val) \
82	: Cfct (Val)) \
83	: (sizeof (__real__ (Val)) == sizeof (Val) \
84	? Fct##f (Val) \
85	: Cfct##f (Val)))))
86
87	# define __TGMATH_UNARY_IMAG_ONLY(Val, Fct) \
88	(__extension__ (sizeof (Val) == sizeof (__complex__ long double) \
89	? Fct##l (Val) \
90	: (sizeof (Val) == sizeof (__complex__ double) \
91	? Fct (Val) \
92	: Fct##f (Val))))
93
94	# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
95	(__extension__ (sizeof (__real__ (Val1)) == sizeof (long double) \
96	\|\| sizeof (__real__ (Val2)) == sizeof (long double) \
97	? (sizeof (__real__ (Val1)) == sizeof (Val1) \
98	&& sizeof (__real__ (Val2)) == sizeof (Val2) \
99	? Fct##l (Val1, Val2) \
100	: Cfct##l (Val1, Val2)) \
101	: (sizeof (__real__ (Val1)) == sizeof (double) \
102	\|\| sizeof (__real__ (Val2)) == sizeof (double) \
103	? (sizeof (__real__ (Val1)) == sizeof (Val1) \
104	&& sizeof (__real__ (Val2)) == sizeof (Val2) \
105	? Fct (Val1, Val2) \
106	: Cfct (Val1, Val2)) \
107	: (sizeof (__real__ (Val1)) == sizeof (Val1) \
108	&& sizeof (__real__ (Val2)) == sizeof (Val2) \
109	? Fct##f (Val1, Val2) \
110	: Cfct##f (Val1, Val2)))))
111	#else
112	# error "Unsupported compiler; you cannot use <tgmath.h>"
113	#endif
114
115
116	/* Unary functions defined for real and complex values. */
117
118
119	/* Trigonometric functions. */
120
121	/* Arc cosine of X. */
122	#define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos)
123	/* Arc sine of X. */
124	#define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin)
125	/* Arc tangent of X. */
126	#define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan)
127	/* Arc tangent of Y/X. */
128	#define atan2(Val) __TGMATH_UNARY_REAL_ONLY (Val, atan2)
129
130	/* Cosine of X. */
131	#define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos)
132	/* Sine of X. */
133	#define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin)
134	/* Tangent of X. */
135	#define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan)
136
137
138	/* Hyperbolic functions. */
139
140	/* Hyperbolic arc cosine of X. */
141	#define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh)
142	/* Hyperbolic arc sine of X. */
143	#define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh)
144	/* Hyperbolic arc tangent of X. */
145	#define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh)
146
147	/* Hyperbolic cosine of X. */
148	#define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh)
149	/* Hyperbolic sine of X. */
150	#define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh)
151	/* Hyperbolic tangent of X. */
152	#define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh)
153
154
155	/* Exponential and logarithmic functions. */
156
157	/* Exponential function of X. */
158	#define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp)
159
160	/* Break VALUE into a normalized fraction and an integral power of 2. */
161	#define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp)
162
163	/* X times (two to the EXP power). */
164	#define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp)
165
166	/* Natural logarithm of X. */
167	#define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog)
168
169	/* Base-ten logarithm of X. */
170	#define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, __clog10)
171
172	/* Return exp(X) - 1. */
173	#define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1)
174
175	/* Return log(1 + X). */
176	#define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p)
177
178	/* Return the base 2 signed integral exponent of X. */
179	#define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb)
180
181	/* Compute base-2 exponential of X. */
182	#define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2)
183
184	/* Compute base-2 logarithm of X. */
185	#define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)
186
187
188	/* Power functions. */
189
190	/* Return X to the Y power. */
191	#define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)
192
193	/* Return the square root of X. */
194	#define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt)
195
196	/* Return `sqrt(XX + YY)'. */
197	#define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot)
198
199	/* Return the cube root of X. */
200	#define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt)
201
202
203	/* Nearest integer, absolute value, and remainder functions. */
204
205	/* Smallest integral value not less than X. */
206	#define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil)
207
208	/* Absolute value of X. */
209	#define fabs(Val) __TGMATH_UNARY_REAL_IMAG (Val, fabs, cabs)
210
211	/* Largest integer not greater than X. */
212	#define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor)
213
214	/* Floating-point modulo remainder of X/Y. */
215	#define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod)
216
217	/* Round X to integral valuein floating-point format using current
218	rounding direction, but do not raise inexact exception. */
219	#define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint)
220
221	/* Round X to nearest integral value, rounding halfway cases away from
222	zero. */
223	#define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round)
224
225	/* Round X to the integral value in floating-point format nearest but
226	not larger in magnitude. */
227	#define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc)
228
229	/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
230	and magnitude congruent `mod 2^n' to the magnitude of the integral
231	quotient x/y, with n >= 3. */
232	#define remquo(Val1, Val2, Val3) \
233	__TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo)
234
235	/* Round X to nearest integral value according to current rounding
236	direction. */
237	#define lrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, lrint)
238	#define llrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, llrint)
239
240	/* Round X to nearest integral value, rounding halfway cases away from
241	zero. */
242	#define lround(Val) __TGMATH_UNARY_REAL_ONLY (Val, lround)
243	#define llround(Val) __TGMATH_UNARY_REAL_ONLY (Val, llround)
244
245
246	/* Return X with its signed changed to Y's. */
247	#define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign)
248
249	/* Error and gamma functions. */
250	#define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf)
251	#define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc)
252	#define gamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, gamma)
253	#define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma)
254
255
256	/* Return the integer nearest X in the direction of the
257	prevailing rounding mode. */
258	#define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)
259
260	/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
261	#define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter)
262	#define nextafterx(Val1, Val2) \
263	__TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, nextafterx)
264
265	/* Return the remainder of integer divison X / Y with infinite precision. */
266	#define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder)
267
268	/* Return X times (2 to the Nth power). */
269	#define scalb(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, scalb)
270
271	/* Return X times (2 to the Nth power). */
272	#define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn)
273
274	/* Return X times (2 to the Nth power). */
275	#define scalbln(Val1, Val2) \
276	__TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln)
277
278	/* Return the binary exponent of X, which must be nonzero. */
279	#define ilogb(Val) __TGMATH_UNARY_REAL_ONLY (Val, ilogb)
280
281
282	/* Return positive difference between X and Y. */
283	#define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)
284
285	/* Return maximum numeric value from X and Y. */
286	#define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax)
287
288	/* Return minimum numeric value from X and Y. */
289	#define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin)
290
291
292	/* Absolute value, conjugates, and projection. */
293
294	/* Argument value of Z. */
295	#define carg(Val) __TGMATH_UNARY_IMAG_ONLY (Val, carg)
296
297	/* Complex conjugate of Z. */
298	#define conj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, conj)
299
300	/* Projection of Z onto the Riemann sphere. */
301	#define cproj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cproj)
302
303
304	/* Decomposing complex values. */
305
306	/* Imaginary part of Z. */
307	#define cimag(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cimag)
308
309	/* Real part of Z. */
310	#define creal(Val) __TGMATH_UNARY_IMAG_ONLY (Val, creal)
311
312	#endif /* tgmath.h */