1 /* Prototype declarations for math functions; helper file for <math.h>.
2 Copyright (C) 1996-2022 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
19 /* NOTE: Because of the special way this file is used by <math.h>, this
20 file must NOT be protected from multiple inclusion as header files
23 This file provides prototype declarations for the math functions.
24 Most functions are declared using the macro:
26 __MATHCALL (NAME,[_r], (ARGS...));
28 This means there is a function `NAME' returning `double' and a function
29 `NAMEf' returning `float'. Each place `_Mdouble_' appears in the
30 prototype, that is actually `double' in the prototype for `NAME' and
31 `float' in the prototype for `NAMEf'. Reentrant variant functions are
32 called `NAME_r' and `NAMEf_r'.
34 Functions returning other types like `int' are declared using the macro:
36 __MATHDECL (TYPE, NAME,[_r], (ARGS...));
38 This is just like __MATHCALL but for a function returning `TYPE'
39 instead of `_Mdouble_'. In all of these cases, there is still
40 both a `NAME' and a `NAMEf' that takes `float' arguments.
42 Note that there must be no whitespace before the argument passed for
43 NAME, to make token pasting work with -traditional. */
46 # error "Never include <bits/mathcalls.h> directly; include <math.h> instead."
50 /* Trigonometric functions. */
52 /* Arc cosine of X. */
53 __MATHCALL_VEC (acos
,, (_Mdouble_ __x
));
55 __MATHCALL_VEC (asin
,, (_Mdouble_ __x
));
56 /* Arc tangent of X. */
57 __MATHCALL_VEC (atan
,, (_Mdouble_ __x
));
58 /* Arc tangent of Y/X. */
59 __MATHCALL_VEC (atan2
,, (_Mdouble_ __y
, _Mdouble_ __x
));
62 __MATHCALL_VEC (cos
,, (_Mdouble_ __x
));
64 __MATHCALL_VEC (sin
,, (_Mdouble_ __x
));
66 __MATHCALL_VEC (tan
,, (_Mdouble_ __x
));
68 /* Hyperbolic functions. */
70 /* Hyperbolic cosine of X. */
71 __MATHCALL_VEC (cosh
,, (_Mdouble_ __x
));
72 /* Hyperbolic sine of X. */
73 __MATHCALL_VEC (sinh
,, (_Mdouble_ __x
));
74 /* Hyperbolic tangent of X. */
75 __MATHCALL_VEC (tanh
,, (_Mdouble_ __x
));
78 /* Cosine and sine of X. */
79 __MATHDECL_VEC (void,sincos
,,
80 (_Mdouble_ __x
, _Mdouble_
*__sinx
, _Mdouble_
*__cosx
));
83 #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
84 /* Hyperbolic arc cosine of X. */
85 __MATHCALL_VEC (acosh
,, (_Mdouble_ __x
));
86 /* Hyperbolic arc sine of X. */
87 __MATHCALL_VEC (asinh
,, (_Mdouble_ __x
));
88 /* Hyperbolic arc tangent of X. */
89 __MATHCALL_VEC (atanh
,, (_Mdouble_ __x
));
92 /* Exponential and logarithmic functions. */
94 /* Exponential function of X. */
95 __MATHCALL_VEC (exp
,, (_Mdouble_ __x
));
97 /* Break VALUE into a normalized fraction and an integral power of 2. */
98 __MATHCALL (frexp
,, (_Mdouble_ __x
, int *__exponent
));
100 /* X times (two to the EXP power). */
101 __MATHCALL (ldexp
,, (_Mdouble_ __x
, int __exponent
));
103 /* Natural logarithm of X. */
104 __MATHCALL_VEC (log
,, (_Mdouble_ __x
));
106 /* Base-ten logarithm of X. */
107 __MATHCALL_VEC (log10
,, (_Mdouble_ __x
));
109 /* Break VALUE into integral and fractional parts. */
110 __MATHCALL (modf
,, (_Mdouble_ __x
, _Mdouble_
*__iptr
)) __nonnull ((2));
112 #if __GLIBC_USE (IEC_60559_FUNCS_EXT_C2X)
113 /* Compute exponent to base ten. */
114 __MATHCALL_VEC (exp10
,, (_Mdouble_ __x
));
117 #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
118 /* Return exp(X) - 1. */
119 __MATHCALL_VEC (expm1
,, (_Mdouble_ __x
));
121 /* Return log(1 + X). */
122 __MATHCALL_VEC (log1p
,, (_Mdouble_ __x
));
124 /* Return the base 2 signed integral exponent of X. */
125 __MATHCALL (logb
,, (_Mdouble_ __x
));
129 /* Compute base-2 exponential of X. */
130 __MATHCALL_VEC (exp2
,, (_Mdouble_ __x
));
132 /* Compute base-2 logarithm of X. */
133 __MATHCALL_VEC (log2
,, (_Mdouble_ __x
));
137 /* Power functions. */
139 /* Return X to the Y power. */
140 __MATHCALL_VEC (pow
,, (_Mdouble_ __x
, _Mdouble_ __y
));
142 /* Return the square root of X. */
143 __MATHCALL (sqrt
,, (_Mdouble_ __x
));
145 #if defined __USE_XOPEN || defined __USE_ISOC99
146 /* Return `sqrt(X*X + Y*Y)'. */
147 __MATHCALL_VEC (hypot
,, (_Mdouble_ __x
, _Mdouble_ __y
));
150 #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
151 /* Return the cube root of X. */
152 __MATHCALL_VEC (cbrt
,, (_Mdouble_ __x
));
156 /* Nearest integer, absolute value, and remainder functions. */
158 /* Smallest integral value not less than X. */
159 __MATHCALLX (ceil
,, (_Mdouble_ __x
), (__const__
));
161 /* Absolute value of X. */
162 __MATHCALLX (fabs
,, (_Mdouble_ __x
), (__const__
));
164 /* Largest integer not greater than X. */
165 __MATHCALLX (floor
,, (_Mdouble_ __x
), (__const__
));
167 /* Floating-point modulo remainder of X/Y. */
168 __MATHCALL (fmod
,, (_Mdouble_ __x
, _Mdouble_ __y
));
171 # if ((!defined __cplusplus \
172 || __cplusplus < 201103L /* isinf conflicts with C++11. */ \
173 || __MATH_DECLARING_DOUBLE == 0)) /* isinff or isinfl don't. */ \
174 && !__MATH_DECLARING_FLOATN
175 /* Return 0 if VALUE is finite or NaN, +1 if it
176 is +Infinity, -1 if it is -Infinity. */
177 __MATHDECL_ALIAS (int,isinf
,, (_Mdouble_ __value
), isinf
)
178 __attribute__ ((__const__
));
181 # if !__MATH_DECLARING_FLOATN
182 /* Return nonzero if VALUE is finite and not NaN. */
183 __MATHDECL_ALIAS (int,finite
,, (_Mdouble_ __value
), finite
)
184 __attribute__ ((__const__
));
186 /* Return the remainder of X/Y. */
187 __MATHCALL (drem
,, (_Mdouble_ __x
, _Mdouble_ __y
));
190 /* Return the fractional part of X after dividing out `ilogb (X)'. */
191 __MATHCALL (significand
,, (_Mdouble_ __x
));
194 #endif /* Use misc. */
197 /* Return X with its signed changed to Y's. */
198 __MATHCALLX (copysign
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
202 /* Return representation of qNaN for double type. */
203 __MATHCALL (nan
,, (const char *__tagb
));
207 #if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
208 # if ((!defined __cplusplus \
209 || __cplusplus < 201103L /* isnan conflicts with C++11. */ \
210 || __MATH_DECLARING_DOUBLE == 0)) /* isnanf or isnanl don't. */ \
211 && !__MATH_DECLARING_FLOATN
212 /* Return nonzero if VALUE is not a number. */
213 __MATHDECL_ALIAS (int,isnan
,, (_Mdouble_ __value
), isnan
)
214 __attribute__ ((__const__
));
218 #if defined __USE_MISC || (defined __USE_XOPEN && __MATH_DECLARING_DOUBLE)
219 /* Bessel functions. */
220 __MATHCALL (j0
,, (_Mdouble_
));
221 __MATHCALL (j1
,, (_Mdouble_
));
222 __MATHCALL (jn
,, (int, _Mdouble_
));
223 __MATHCALL (y0
,, (_Mdouble_
));
224 __MATHCALL (y1
,, (_Mdouble_
));
225 __MATHCALL (yn
,, (int, _Mdouble_
));
229 #if defined __USE_XOPEN || defined __USE_ISOC99
230 /* Error and gamma functions. */
231 __MATHCALL_VEC (erf
,, (_Mdouble_
));
232 __MATHCALL_VEC (erfc
,, (_Mdouble_
));
233 __MATHCALL (lgamma
,, (_Mdouble_
));
237 /* True gamma function. */
238 __MATHCALL (tgamma
,, (_Mdouble_
));
241 #if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
242 # if !__MATH_DECLARING_FLOATN
243 /* Obsolete alias for `lgamma'. */
244 __MATHCALL (gamma
,, (_Mdouble_
));
249 /* Reentrant version of lgamma. This function uses the global variable
250 `signgam'. The reentrant version instead takes a pointer and stores
251 the value through it. */
252 __MATHCALL (lgamma
,_r
, (_Mdouble_
, int *__signgamp
));
256 #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
257 /* Return the integer nearest X in the direction of the
258 prevailing rounding mode. */
259 __MATHCALL (rint
,, (_Mdouble_ __x
));
261 /* Return X + epsilon if X < Y, X - epsilon if X > Y. */
262 __MATHCALL (nextafter
,, (_Mdouble_ __x
, _Mdouble_ __y
));
263 # if defined __USE_ISOC99 && !defined __LDBL_COMPAT && !__MATH_DECLARING_FLOATN
264 __MATHCALL (nexttoward
,, (_Mdouble_ __x
, long double __y
));
267 # if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN
268 /* Return X - epsilon. */
269 __MATHCALL (nextdown
,, (_Mdouble_ __x
));
270 /* Return X + epsilon. */
271 __MATHCALL (nextup
,, (_Mdouble_ __x
));
274 /* Return the remainder of integer divison X / Y with infinite precision. */
275 __MATHCALL (remainder
,, (_Mdouble_ __x
, _Mdouble_ __y
));
278 /* Return X times (2 to the Nth power). */
279 __MATHCALL (scalbn
,, (_Mdouble_ __x
, int __n
));
282 /* Return the binary exponent of X, which must be nonzero. */
283 __MATHDECL (int,ilogb
,, (_Mdouble_ __x
));
286 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN
287 /* Like ilogb, but returning long int. */
288 __MATHDECL (long int, llogb
,, (_Mdouble_ __x
));
292 /* Return X times (2 to the Nth power). */
293 __MATHCALL (scalbln
,, (_Mdouble_ __x
, long int __n
));
295 /* Round X to integral value in floating-point format using current
296 rounding direction, but do not raise inexact exception. */
297 __MATHCALL (nearbyint
,, (_Mdouble_ __x
));
299 /* Round X to nearest integral value, rounding halfway cases away from
301 __MATHCALLX (round
,, (_Mdouble_ __x
), (__const__
));
303 /* Round X to the integral value in floating-point format nearest but
304 not larger in magnitude. */
305 __MATHCALLX (trunc
,, (_Mdouble_ __x
), (__const__
));
307 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
308 and magnitude congruent `mod 2^n' to the magnitude of the integral
309 quotient x/y, with n >= 3. */
310 __MATHCALL (remquo
,, (_Mdouble_ __x
, _Mdouble_ __y
, int *__quo
));
313 /* Conversion functions. */
315 /* Round X to nearest integral value according to current rounding
317 __MATHDECL (long int,lrint
,, (_Mdouble_ __x
));
319 __MATHDECL (long long int,llrint
,, (_Mdouble_ __x
));
321 /* Round X to nearest integral value, rounding halfway cases away from
323 __MATHDECL (long int,lround
,, (_Mdouble_ __x
));
325 __MATHDECL (long long int,llround
,, (_Mdouble_ __x
));
328 /* Return positive difference between X and Y. */
329 __MATHCALL (fdim
,, (_Mdouble_ __x
, _Mdouble_ __y
));
331 # if !__MATH_DECLARING_FLOATN || defined __USE_GNU || !__GLIBC_USE (ISOC2X)
332 /* Return maximum numeric value from X and Y. */
333 __MATHCALLX (fmax
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
335 /* Return minimum numeric value from X and Y. */
336 __MATHCALLX (fmin
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
339 /* Multiply-add function computed as a ternary operation. */
340 __MATHCALL (fma
,, (_Mdouble_ __x
, _Mdouble_ __y
, _Mdouble_ __z
));
341 #endif /* Use ISO C99. */
343 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN
344 /* Round X to nearest integer value, rounding halfway cases to even. */
345 __MATHCALLX (roundeven
,, (_Mdouble_ __x
), (__const__
));
347 /* Round X to nearest signed integer value, not raising inexact, with
348 control of rounding direction and width of result. */
349 __MATHDECL (__intmax_t
, fromfp
,, (_Mdouble_ __x
, int __round
,
350 unsigned int __width
));
352 /* Round X to nearest unsigned integer value, not raising inexact,
353 with control of rounding direction and width of result. */
354 __MATHDECL (__uintmax_t
, ufromfp
,, (_Mdouble_ __x
, int __round
,
355 unsigned int __width
));
357 /* Round X to nearest signed integer value, raising inexact for
358 non-integers, with control of rounding direction and width of
360 __MATHDECL (__intmax_t
, fromfpx
,, (_Mdouble_ __x
, int __round
,
361 unsigned int __width
));
363 /* Round X to nearest unsigned integer value, raising inexact for
364 non-integers, with control of rounding direction and width of
366 __MATHDECL (__uintmax_t
, ufromfpx
,, (_Mdouble_ __x
, int __round
,
367 unsigned int __width
));
369 /* Canonicalize floating-point representation. */
370 __MATHDECL_1 (int, canonicalize
,, (_Mdouble_
*__cx
, const _Mdouble_
*__x
));
373 #if (__GLIBC_USE (IEC_60559_BFP_EXT) \
374 || (__MATH_DECLARING_FLOATN \
375 && (defined __USE_GNU || !__GLIBC_USE (ISOC2X))))
376 /* Return value with maximum magnitude. */
377 __MATHCALLX (fmaxmag
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
379 /* Return value with minimum magnitude. */
380 __MATHCALLX (fminmag
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
383 #if __GLIBC_USE (ISOC2X)
384 /* Return maximum value from X and Y. */
385 __MATHCALLX (fmaximum
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
387 /* Return minimum value from X and Y. */
388 __MATHCALLX (fminimum
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
390 /* Return maximum numeric value from X and Y. */
391 __MATHCALLX (fmaximum_num
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
393 /* Return minimum numeric value from X and Y. */
394 __MATHCALLX (fminimum_num
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
396 /* Return value with maximum magnitude. */
397 __MATHCALLX (fmaximum_mag
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
399 /* Return value with minimum magnitude. */
400 __MATHCALLX (fminimum_mag
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
402 /* Return numeric value with maximum magnitude. */
403 __MATHCALLX (fmaximum_mag_num
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
405 /* Return numeric value with minimum magnitude. */
406 __MATHCALLX (fminimum_mag_num
,, (_Mdouble_ __x
, _Mdouble_ __y
), (__const__
));
409 #if __GLIBC_USE (IEC_60559_EXT) || __MATH_DECLARING_FLOATN
410 /* Total order operation. */
411 __MATHDECL_1 (int, totalorder
,, (const _Mdouble_
*__x
,
412 const _Mdouble_
*__y
))
415 /* Total order operation on absolute values. */
416 __MATHDECL_1 (int, totalordermag
,, (const _Mdouble_
*__x
,
417 const _Mdouble_
*__y
))
420 /* Get NaN payload. */
421 __MATHCALL (getpayload
,, (const _Mdouble_
*__x
));
423 /* Set quiet NaN payload. */
424 __MATHDECL_1 (int, setpayload
,, (_Mdouble_
*__x
, _Mdouble_ __payload
));
426 /* Set signaling NaN payload. */
427 __MATHDECL_1 (int, setpayloadsig
,, (_Mdouble_
*__x
, _Mdouble_ __payload
));
430 #if (defined __USE_MISC || (defined __USE_XOPEN_EXTENDED \
431 && __MATH_DECLARING_DOUBLE \
432 && !defined __USE_XOPEN2K8)) \
433 && !__MATH_DECLARING_FLOATN
434 /* Return X times (2 to the Nth power). */
435 __MATHCALL (scalb
,, (_Mdouble_ __x
, _Mdouble_ __n
));