1/* Prototype declarations for math functions; helper file for <math.h>.
2 Copyright (C) 1996-2026 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 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, see
17 <https://www.gnu.org/licenses/>. */
18
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
21 usually are.
22
23 This file provides prototype declarations for the math functions.
24 Most functions are declared using the macro:
25
26 __MATHCALL (NAME,[_r], (ARGS...));
27
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'.
33
34 Functions returning other types like `int' are declared using the macro:
35
36 __MATHDECL (TYPE, NAME,[_r], (ARGS...));
37
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.
41
42 Note that there must be no whitespace before the argument passed for
43 NAME, to make token pasting work with -traditional. */
44
45#ifndef _MATH_H
46# error "Never include <bits/mathcalls.h> directly; include <math.h> instead."
47#endif
48
49
50/* Trigonometric functions. */
51
52/* Arc cosine of X. */
53__MATHCALL_VEC (acos,, (_Mdouble_ __x));
54/* Arc sine of 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));
60
61/* Cosine of X. */
62__MATHCALL_VEC (cos,, (_Mdouble_ __x));
63/* Sine of X. */
64__MATHCALL_VEC (sin,, (_Mdouble_ __x));
65/* Tangent of X. */
66__MATHCALL_VEC (tan,, (_Mdouble_ __x));
67
68#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23)
69/* Arc cosine of X, divided by pi. */
70__MATHCALL (acospi,, (_Mdouble_ __x));
71__MATHCALL_VEC (acospi,, (_Mdouble_ __x));
72/* Arc sine of X, divided by pi. */
73__MATHCALL (asinpi,, (_Mdouble_ __x));
74__MATHCALL_VEC (asinpi,, (_Mdouble_ __x));
75/* Arc tangent of X, divided by pi. */
76__MATHCALL (atanpi,, (_Mdouble_ __x));
77__MATHCALL_VEC (atanpi,, (_Mdouble_ __x));
78/* Arc tangent of Y/X, divided by pi. */
79__MATHCALL (atan2pi,, (_Mdouble_ __y, _Mdouble_ __x));
80__MATHCALL_VEC (atan2pi,, (_Mdouble_ __y, _Mdouble_ __x));
81
82/* Cosine of pi * X. */
83__MATHCALL_VEC (cospi,, (_Mdouble_ __x));
84/* Sine of pi * X. */
85__MATHCALL_VEC (sinpi,, (_Mdouble_ __x));
86/* Tangent of pi * X. */
87__MATHCALL_VEC (tanpi,, (_Mdouble_ __x));
88#endif
89
90/* Hyperbolic functions. */
91
92/* Hyperbolic cosine of X. */
93__MATHCALL_VEC (cosh,, (_Mdouble_ __x));
94/* Hyperbolic sine of X. */
95__MATHCALL_VEC (sinh,, (_Mdouble_ __x));
96/* Hyperbolic tangent of X. */
97__MATHCALL_VEC (tanh,, (_Mdouble_ __x));
98
99#ifdef __USE_GNU
100/* Cosine and sine of X. */
101__MATHDECL_VEC (void,sincos,,
102 (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
103#endif
104
105#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
106/* Hyperbolic arc cosine of X. */
107__MATHCALL_VEC (acosh,, (_Mdouble_ __x));
108/* Hyperbolic arc sine of X. */
109__MATHCALL_VEC (asinh,, (_Mdouble_ __x));
110/* Hyperbolic arc tangent of X. */
111__MATHCALL_VEC (atanh,, (_Mdouble_ __x));
112#endif
113
114/* Exponential and logarithmic functions. */
115
116/* Exponential function of X. */
117__MATHCALL_VEC (exp,, (_Mdouble_ __x));
118
119/* Break VALUE into a normalized fraction and an integral power of 2. */
120__MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
121
122/* X times (two to the EXP power). */
123__MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
124
125/* Natural logarithm of X. */
126__MATHCALL_VEC (log,, (_Mdouble_ __x));
127
128/* Base-ten logarithm of X. */
129__MATHCALL_VEC (log10,, (_Mdouble_ __x));
130
131/* Break VALUE into integral and fractional parts. */
132__MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
133
134#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23)
135/* Compute exponent to base ten. */
136__MATHCALL_VEC (exp10,, (_Mdouble_ __x));
137
138/* Return exp2(X) - 1. */
139__MATHCALL_VEC (exp2m1,, (_Mdouble_ __x));
140
141/* Return exp10(X) - 1. */
142__MATHCALL_VEC (exp10m1,, (_Mdouble_ __x));
143
144/* Return log2(1 + X). */
145__MATHCALL_VEC (log2p1,, (_Mdouble_ __x));
146
147/* Return log10(1 + X). */
148__MATHCALL_VEC (log10p1,, (_Mdouble_ __x));
149
150/* Return log(1 + X). */
151__MATHCALL_VEC (logp1,, (_Mdouble_ __x));
152#endif
153
154#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
155/* Return exp(X) - 1. */
156__MATHCALL_VEC (expm1,, (_Mdouble_ __x));
157
158/* Return log(1 + X). */
159__MATHCALL_VEC (log1p,, (_Mdouble_ __x));
160
161/* Return the base 2 signed integral exponent of X. */
162__MATHCALL (logb,, (_Mdouble_ __x));
163#endif
164
165#ifdef __USE_ISOC99
166/* Compute base-2 exponential of X. */
167__MATHCALL_VEC (exp2,, (_Mdouble_ __x));
168
169/* Compute base-2 logarithm of X. */
170__MATHCALL_VEC (log2,, (_Mdouble_ __x));
171#endif
172
173
174/* Power functions. */
175
176/* Return X to the Y power. */
177__MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y));
178
179/* Return the square root of X. */
180__MATHCALL (sqrt,, (_Mdouble_ __x));
181
182#if defined __USE_XOPEN || defined __USE_ISOC99
183/* Return `sqrt(X*X + Y*Y)'. */
184__MATHCALL_VEC (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
185#endif
186
187#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
188/* Return the cube root of X. */
189__MATHCALL_VEC (cbrt,, (_Mdouble_ __x));
190#endif
191
192#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23)
193/* Return 1+X to the Y power. */
194__MATHCALL (compoundn,, (_Mdouble_ __x, long long int __y));
195
196/* Return X to the Y power. */
197__MATHCALL (pown,, (_Mdouble_ __x, long long int __y));
198
199/* Return X to the Y power. */
200__MATHCALL_VEC (powr,, (_Mdouble_ __x, _Mdouble_ __y));
201__MATHCALL (powr,, (_Mdouble_ __x, _Mdouble_ __y));
202
203/* Return the Yth root of X. */
204__MATHCALL (rootn,, (_Mdouble_ __x, long long int __y));
205
206/* Return the reciprocal of the square root of X. */
207__MATHCALL_VEC (rsqrt,, (_Mdouble_ __x));
208#endif
209
210
211/* Nearest integer, absolute value, and remainder functions. */
212
213/* Smallest integral value not less than X. */
214__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
215
216/* Absolute value of X. */
217__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
218
219/* Largest integer not greater than X. */
220__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
221
222/* Floating-point modulo remainder of X/Y. */
223__MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
224
225#ifdef __USE_MISC
226# if ((!defined __cplusplus \
227 || __cplusplus < 201103L /* isinf conflicts with C++11. */ \
228 || __MATH_DECLARING_DOUBLE == 0)) /* isinff or isinfl don't. */ \
229 && !__MATH_DECLARING_FLOATN
230/* Return 0 if VALUE is finite or NaN, +1 if it
231 is +Infinity, -1 if it is -Infinity. */
232__MATHDECL_ALIAS (int,isinf,, (_Mdouble_ __value), isinf)
233 __attribute__ ((__const__));
234# endif
235
236# if !__MATH_DECLARING_FLOATN
237/* Return nonzero if VALUE is finite and not NaN. */
238__MATHDECL_ALIAS (int,finite,, (_Mdouble_ __value), finite)
239 __attribute__ ((__const__));
240
241/* Return the remainder of X/Y. */
242__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
243
244
245/* Return the fractional part of X after dividing out `ilogb (X)'. */
246__MATHCALL (significand,, (_Mdouble_ __x));
247# endif
248
249#endif /* Use misc. */
250
251#ifdef __USE_ISOC99
252/* Return X with its signed changed to Y's. */
253__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
254#endif
255
256#ifdef __USE_ISOC99
257/* Return representation of qNaN for double type. */
258__MATHCALL (nan,, (const char *__tagb));
259#endif
260
261
262#if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
263# if ((!defined __cplusplus \
264 || __cplusplus < 201103L /* isnan conflicts with C++11. */ \
265 || __MATH_DECLARING_DOUBLE == 0)) /* isnanf or isnanl don't. */ \
266 && !__MATH_DECLARING_FLOATN
267/* Return nonzero if VALUE is not a number. */
268__MATHDECL_ALIAS (int,isnan,, (_Mdouble_ __value), isnan)
269 __attribute__ ((__const__));
270# endif
271#endif
272
273#if defined __USE_MISC || (defined __USE_XOPEN && __MATH_DECLARING_DOUBLE)
274/* Bessel functions. */
275__MATHCALL (j0,, (_Mdouble_));
276__MATHCALL (j1,, (_Mdouble_));
277__MATHCALL (jn,, (int, _Mdouble_));
278__MATHCALL (y0,, (_Mdouble_));
279__MATHCALL (y1,, (_Mdouble_));
280__MATHCALL (yn,, (int, _Mdouble_));
281#endif
282
283
284#if defined __USE_XOPEN || defined __USE_ISOC99
285/* Error and gamma functions. */
286__MATHCALL_VEC (erf,, (_Mdouble_));
287__MATHCALL_VEC (erfc,, (_Mdouble_));
288__MATHCALL (lgamma,, (_Mdouble_));
289#endif
290
291#ifdef __USE_ISOC99
292/* True gamma function. */
293__MATHCALL (tgamma,, (_Mdouble_));
294#endif
295
296#if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
297# if !__MATH_DECLARING_FLOATN
298/* Obsolete alias for `lgamma'. */
299__MATHCALL (gamma,, (_Mdouble_));
300# endif
301#endif
302
303#ifdef __USE_MISC
304/* Reentrant version of lgamma. This function uses the global variable
305 `signgam'. The reentrant version instead takes a pointer and stores
306 the value through it. */
307__MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
308#endif
309
310
311#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
312/* Return the integer nearest X in the direction of the
313 prevailing rounding mode. */
314__MATHCALL (rint,, (_Mdouble_ __x));
315
316/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
317__MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y));
318# if defined __USE_ISOC99 && !defined __LDBL_COMPAT && !__MATH_DECLARING_FLOATN
319__MATHCALL (nexttoward,, (_Mdouble_ __x, long double __y));
320# endif
321
322# if __GLIBC_USE (IEC_60559_BFP_EXT_C23) || __MATH_DECLARING_FLOATN
323/* Return X - epsilon. */
324__MATHCALL (nextdown,, (_Mdouble_ __x));
325/* Return X + epsilon. */
326__MATHCALL (nextup,, (_Mdouble_ __x));
327# endif
328
329/* Return the remainder of integer division X / Y with infinite precision. */
330__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
331
332# ifdef __USE_ISOC99
333/* Return X times (2 to the Nth power). */
334__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
335# endif
336
337/* Return the binary exponent of X, which must be nonzero. */
338__MATHDECL (int,ilogb,, (_Mdouble_ __x));
339#endif
340
341#if __GLIBC_USE (IEC_60559_BFP_EXT_C23) || __MATH_DECLARING_FLOATN
342/* Like ilogb, but returning long int. */
343__MATHDECL (long int, llogb,, (_Mdouble_ __x));
344#endif
345
346#ifdef __USE_ISOC99
347/* Return X times (2 to the Nth power). */
348__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
349
350/* Round X to integral value in floating-point format using current
351 rounding direction, but do not raise inexact exception. */
352__MATHCALL (nearbyint,, (_Mdouble_ __x));
353
354/* Round X to nearest integral value, rounding halfway cases away from
355 zero. */
356__MATHCALLX (round,, (_Mdouble_ __x), (__const__));
357
358/* Round X to the integral value in floating-point format nearest but
359 not larger in magnitude. */
360__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
361
362/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
363 and magnitude congruent `mod 2^n' to the magnitude of the integral
364 quotient x/y, with n >= 3. */
365__MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
366
367
368/* Conversion functions. */
369
370/* Round X to nearest integral value according to current rounding
371 direction. */
372__MATHDECL (long int,lrint,, (_Mdouble_ __x));
373__extension__
374__MATHDECL (long long int,llrint,, (_Mdouble_ __x));
375
376/* Round X to nearest integral value, rounding halfway cases away from
377 zero. */
378__MATHDECL (long int,lround,, (_Mdouble_ __x));
379__extension__
380__MATHDECL (long long int,llround,, (_Mdouble_ __x));
381
382
383/* Return positive difference between X and Y. */
384__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
385
386# if !__MATH_DECLARING_FLOATN || defined __USE_GNU || !__GLIBC_USE (ISOC23)
387/* Return maximum numeric value from X and Y. */
388__MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
389
390/* Return minimum numeric value from X and Y. */
391__MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
392# endif
393
394/* Multiply-add function computed as a ternary operation. */
395__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
396#endif /* Use ISO C99. */
397
398#if __GLIBC_USE (IEC_60559_BFP_EXT_C23) || __MATH_DECLARING_FLOATN
399/* Round X to nearest integer value, rounding halfway cases to even. */
400__MATHCALLX (roundeven,, (_Mdouble_ __x), (__const__));
401
402/* Round X to nearest signed integer value, not raising inexact, with
403 control of rounding direction and width of result. */
404__MATHCALL (fromfp,, (_Mdouble_ __x, int __round, unsigned int __width));
405
406/* Round X to nearest unsigned integer value, not raising inexact,
407 with control of rounding direction and width of result. */
408__MATHCALL (ufromfp,, (_Mdouble_ __x, int __round, unsigned int __width));
409
410/* Round X to nearest signed integer value, raising inexact for
411 non-integers, with control of rounding direction and width of
412 result. */
413__MATHCALL (fromfpx,, (_Mdouble_ __x, int __round, unsigned int __width));
414
415/* Round X to nearest unsigned integer value, raising inexact for
416 non-integers, with control of rounding direction and width of
417 result. */
418__MATHCALL (ufromfpx,, (_Mdouble_ __x, int __round, unsigned int __width));
419
420/* Canonicalize floating-point representation. */
421__MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));
422#endif
423
424#if (__GLIBC_USE (IEC_60559_BFP_EXT) \
425 || (__MATH_DECLARING_FLOATN \
426 && (defined __USE_GNU || !__GLIBC_USE (ISOC23))))
427/* Return value with maximum magnitude. */
428__MATHCALLX (fmaxmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
429
430/* Return value with minimum magnitude. */
431__MATHCALLX (fminmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
432#endif
433
434#if __GLIBC_USE (ISOC23)
435/* Return maximum value from X and Y. */
436__MATHCALLX (fmaximum,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
437
438/* Return minimum value from X and Y. */
439__MATHCALLX (fminimum,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
440
441/* Return maximum numeric value from X and Y. */
442__MATHCALLX (fmaximum_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
443
444/* Return minimum numeric value from X and Y. */
445__MATHCALLX (fminimum_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
446
447/* Return value with maximum magnitude. */
448__MATHCALLX (fmaximum_mag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
449
450/* Return value with minimum magnitude. */
451__MATHCALLX (fminimum_mag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
452
453/* Return numeric value with maximum magnitude. */
454__MATHCALLX (fmaximum_mag_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
455
456/* Return numeric value with minimum magnitude. */
457__MATHCALLX (fminimum_mag_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
458#endif
459
460#if __GLIBC_USE (IEC_60559_EXT) || __MATH_DECLARING_FLOATN
461/* Total order operation. */
462__MATHDECL_1 (int, totalorder,, (const _Mdouble_ *__x,
463 const _Mdouble_ *__y))
464 __attribute_pure__;
465
466/* Total order operation on absolute values. */
467__MATHDECL_1 (int, totalordermag,, (const _Mdouble_ *__x,
468 const _Mdouble_ *__y))
469 __attribute_pure__;
470
471/* Get NaN payload. */
472__MATHCALL (getpayload,, (const _Mdouble_ *__x));
473
474/* Set quiet NaN payload. */
475__MATHDECL_1 (int, setpayload,, (_Mdouble_ *__x, _Mdouble_ __payload));
476
477/* Set signaling NaN payload. */
478__MATHDECL_1 (int, setpayloadsig,, (_Mdouble_ *__x, _Mdouble_ __payload));
479#endif
480
481#if (defined __USE_MISC || (defined __USE_XOPEN_EXTENDED \
482 && __MATH_DECLARING_DOUBLE \
483 && !defined __USE_XOPEN2K8)) \
484 && !__MATH_DECLARING_FLOATN
485/* Return X times (2 to the Nth power). */
486__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
487#endif
488