(gmp-objs): Add udiv_qrnnd.
[kopensolaris-gnu/glibc.git] / math / bits / mathcalls.h
1 /* Prototype declarations for math functions; helper file for <math.h>.
2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    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    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 /* NOTE: Because of the special way this file is used by <math.h>, this
21    file must NOT be protected from multiple inclusion as header files
22    usually are.
23
24    This file provides prototype declarations for the math functions.
25    Most functions are declared using the macro:
26
27    __MATHCALL (NAME,[_r], (ARGS...));
28
29    This means there is a function `NAME' returning `double' and a function
30    `NAMEf' returning `float'.  Each place `_Mdouble_' appears in the
31    prototype, that is actually `double' in the prototype for `NAME' and
32    `float' in the prototype for `NAMEf'.  Reentrant variant functions are
33    called `NAME_r' and `NAMEf_r'.
34
35    Functions returning other types like `int' are declared using the macro:
36
37    __MATHDECL (TYPE, NAME,[_r], (ARGS...));
38
39    This is just like __MATHCALL but for a function returning `TYPE'
40    instead of `_Mdouble_'.  In all of these cases, there is still
41    both a `NAME' and a `NAMEf' that takes `float' arguments.
42
43    Note that there must be no whitespace before the argument passed for
44    NAME, to make token pasting work with -traditional.  */
45
46 #ifndef _MATH_H
47  #error "Never include <bits/mathcalls.h> directly; include <math.h> instead."
48 #endif
49
50
51 /* Trigonometric functions.  */
52
53 /* Arc cosine of X.  */
54 __MATHCALL (acos,, (_Mdouble_ __x));
55 /* Arc sine of X.  */
56 __MATHCALL (asin,, (_Mdouble_ __x));
57 /* Arc tangent of X.  */
58 __MATHCALL (atan,, (_Mdouble_ __x));
59 /* Arc tangent of Y/X.  */
60 __MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
61
62 /* Cosine of X.  */
63 __MATHCALL (cos,, (_Mdouble_ __x));
64 /* Sine of X.  */
65 __MATHCALL (sin,, (_Mdouble_ __x));
66 /* Tangent of X.  */
67 __MATHCALL (tan,, (_Mdouble_ __x));
68
69 #ifdef __USE_GNU
70 /* Cosine and sine of X.  */
71 __MATHDECL (void,sincos,,
72             (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
73 #endif
74
75 /* Hyperbolic functions.  */
76
77 /* Hyperbolic cosine of X.  */
78 __MATHCALL (cosh,, (_Mdouble_ __x));
79 /* Hyperbolic sine of X.  */
80 __MATHCALL (sinh,, (_Mdouble_ __x));
81 /* Hyperbolic tangent of X.  */
82 __MATHCALL (tanh,, (_Mdouble_ __x));
83
84 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
85 /* Hyperbolic arc cosine of X.  */
86 __MATHCALL (acosh,, (_Mdouble_ __x));
87 /* Hyperbolic arc sine of X.  */
88 __MATHCALL (asinh,, (_Mdouble_ __x));
89 /* Hyperbolic arc tangent of X.  */
90 __MATHCALL (atanh,, (_Mdouble_ __x));
91 #endif
92
93 /* Exponential and logarithmic functions.  */
94
95 /* Exponential function of X.  */
96 __MATHCALL (exp,, (_Mdouble_ __x));
97
98 #ifdef __USE_GNU
99 /* A function missing in all standards: compute exponent to base ten.  */
100 __MATHCALL (exp10,, (_Mdouble_ __x));
101 /* Another name occasionally used.  */
102 __MATHCALL (pow10,, (_Mdouble_ __x));
103 #endif
104
105 /* Break VALUE into a normalized fraction and an integral power of 2.  */
106 __MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
107
108 /* X times (two to the EXP power).  */
109 __MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
110
111 /* Natural logarithm of X.  */
112 __MATHCALL (log,, (_Mdouble_ __x));
113
114 /* Base-ten logarithm of X.  */
115 __MATHCALL (log10,, (_Mdouble_ __x));
116
117 /* Break VALUE into integral and fractional parts.  */
118 __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));
119
120 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
121 /* Return exp(X) - 1.  */
122 __MATHCALL (expm1,, (_Mdouble_ __x));
123
124 /* Return log(1 + X).  */
125 __MATHCALL (log1p,, (_Mdouble_ __x));
126
127 /* Return the base 2 signed integral exponent of X.  */
128 __MATHCALL (logb,, (_Mdouble_ __x));
129 #endif
130
131 #ifdef __USE_ISOC9X
132 /* Compute base-2 exponential of X.  */
133 __MATHCALL (exp2,, (_Mdouble_ __x));
134
135 /* Compute base-2 logarithm of X.  */
136 __MATHCALL (log2,, (_Mdouble_ __x));
137 #endif
138
139
140 /* Power functions.  */
141
142 /* Return X to the Y power.  */
143 __MATHCALL (pow,, (_Mdouble_ __x, _Mdouble_ __y));
144
145 /* Return the square root of X.  */
146 __MATHCALL (sqrt,, (_Mdouble_ __x));
147
148 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC9X
149 /* Return `sqrt(X*X + Y*Y)'.  */
150 __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
151 #endif
152
153 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
154 /* Return the cube root of X.  */
155 __MATHCALL (cbrt,, (_Mdouble_ __x));
156 #endif
157
158
159 /* Nearest integer, absolute value, and remainder functions.  */
160
161 /* Smallest integral value not less than X.  */
162 __MATHCALL (ceil,, (_Mdouble_ __x));
163
164 /* Absolute value of X.  */
165 __MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
166
167 /* Largest integer not greater than X.  */
168 __MATHCALL (floor,, (_Mdouble_ __x));
169
170 /* Floating-point modulo remainder of X/Y.  */
171 __MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
172
173
174 /* Return 0 if VALUE is finite or NaN, +1 if it
175    is +Infinity, -1 if it is -Infinity.  */
176 __MATHDECL_1 (int,__isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
177
178 #ifdef __USE_MISC
179 /* Return 0 if VALUE is finite or NaN, +1 if it
180    is +Infinity, -1 if it is -Infinity.  */
181 __MATHDECL_1 (int,isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
182
183 /* Return nonzero if VALUE is finite and not NaN.  */
184 __MATHDECLX (int,finite,, (_Mdouble_ __value), (__const__));
185
186 /* Deal with an infinite or NaN result.
187    If ERROR is ERANGE, result is +Inf;
188    if ERROR is - ERANGE, result is -Inf;
189    otherwise result is NaN.
190    This will set `errno' to either ERANGE or EDOM,
191    and may return an infinity or NaN, or may do something else.  */
192 __MATHCALLX (infnan,, (int __error), (__const__));
193
194 /* Return the remainder of X/Y.  */
195 __MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
196
197
198 /* Return the fractional part of X after dividing out `ilogb (X)'.  */
199 __MATHCALL (significand,, (_Mdouble_ __x));
200 #endif /* Use misc.  */
201
202 #if defined __USE_MISC || defined __USE_ISOC9X
203 /* Return X with its signed changed to Y's.  */
204 __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
205 #endif
206
207 #ifdef __USE_ISOC9X
208 /* Return representation of NaN for double type.  */
209 __MATHCALLX (nan,, (__const char *__tagb), (__const__));
210 #endif
211
212
213 #if defined __USE_MISC || defined __USE_XOPEN
214 /* Return nonzero if VALUE is not a number.  */
215 __MATHDECLX (int,isnan,, (_Mdouble_ __value), (__const__));
216
217 /* Bessel functions.  */
218 __MATHCALL (j0,, (_Mdouble_));
219 __MATHCALL (j1,, (_Mdouble_));
220 __MATHCALL (jn,, (int, _Mdouble_));
221 __MATHCALL (y0,, (_Mdouble_));
222 __MATHCALL (y1,, (_Mdouble_));
223 __MATHCALL (yn,, (int, _Mdouble_));
224 #endif
225
226
227 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC9X
228 /* Error, gamma, and Bessel functions.  */
229 __MATHCALL (erf,, (_Mdouble_));
230 __MATHCALL (erfc,, (_Mdouble_));
231 __MATHCALL (lgamma,, (_Mdouble_));
232 __MATHCALL (tgamma,, (_Mdouble_));
233 #endif
234
235 #if defined __USE_MISC || defined __USE_XOPEN
236 __MATHCALL (gamma,, (_Mdouble_));
237 #endif
238
239 #ifdef __USE_MISC
240 /* Reentrant versions of gamma and lgamma.  Those functions use the global
241    variable `signgam'.  The reentrant versions instead take a pointer and
242    store the value through it.  */
243 __MATHCALL (gamma,_r, (_Mdouble_, int *));
244 __MATHCALL (lgamma,_r, (_Mdouble_, int *));
245 #endif
246
247
248 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC9X
249 /* Return the integer nearest X in the direction of the
250    prevailing rounding mode.  */
251 __MATHCALL (rint,, (_Mdouble_ __x));
252
253 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
254 __MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
255 # ifdef __USE_ISOC9X
256 __MATHCALLX (nextafterx,, (_Mdouble_ __x, long double __y), (__const__));
257 # endif
258
259 /* Return the remainder of integer divison X / Y with infinite precision.  */
260 __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
261
262 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
263 /* Return X times (2 to the Nth power).  */
264 __MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
265 #endif
266
267 /* Return X times (2 to the Nth power).  */
268 __MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
269
270 /* Return the binary exponent of X, which must be nonzero.  */
271 __MATHDECL (int,ilogb,, (_Mdouble_ __x));
272 #endif
273
274 #ifdef __USE_ISOC9X
275 /* Return X times (2 to the Nth power).  */
276 __MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
277
278 /* Round X to integral valuein floating-point format using current
279    rounding direction, but do not raise inexact exception.  */
280 __MATHCALL (nearbyint,, (_Mdouble_ __x));
281
282 /* Round X to nearest integral value, rounding halfway cases away from
283    zero.  */
284 __MATHCALL (round,, (_Mdouble_ __x));
285
286 /* Round X to the integral value in floating-point format nearest but
287    not larger in magnitude.  */
288 __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
289
290 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
291    and magnitude congruent `mod 2^n' to the magnitude of the integral
292    quotient x/y, with n >= 3.  */
293 __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
294
295
296 /* Conversion functions.  */
297
298 /* Round X to nearest integral value according to current rounding
299    direction.  */
300 __MATHDECL (long int,lrint,, (_Mdouble_ __x));
301 __MATHDECL (long long int,llrint,, (_Mdouble_ __x));
302
303 /* Round X to nearest integral value, rounding halfway cases away from
304    zero.  */
305 __MATHDECL (long int,lround,, (_Mdouble_ __x));
306 __MATHDECL (long long int,llround,, (_Mdouble_ __x));
307
308
309 /* Return positive difference between X and Y.  */
310 __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
311
312 /* Return maximum numeric value from X and Y.  */
313 __MATHCALL (fmax,, (_Mdouble_ __x, _Mdouble_ __y));
314
315 /* Return minimum numeric value from X and Y.  */
316 __MATHCALL (fmin,, (_Mdouble_ __x, _Mdouble_ __y));
317
318
319 /* Classify given number.  */
320 __MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
321      __attribute__ ((__const__));
322
323 /* Test for negative number.  */
324 __MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
325      __attribute__ ((__const__));
326
327
328 /* Multiply-add function computed as a ternary operation.  */
329 __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
330 #endif /* Use ISO C 9X.  */