The C and C++ Include Header Files

/usr/include/x86_64-linux-gnu/bits/mathcalls.h


$ cat -n /usr/include/x86_64-linux-gnu/bits/mathcalls.h

     1	/* Prototype declarations for math functions; helper file for <math.h>.
     2	   Copyright (C) 1996-2024 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	/* Hyperbolic functions.  */
    69	
    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));
    76	
    77	#ifdef __USE_GNU
    78	/* Cosine and sine of X.  */
    79	__MATHDECL_VEC (void,sincos,,
    80			(_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
    81	#endif
    82	
    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));
    90	#endif
    91	
    92	/* Exponential and logarithmic functions.  */
    93	
    94	/* Exponential function of X.  */
    95	__MATHCALL_VEC (exp,, (_Mdouble_ __x));
    96	
    97	/* Break VALUE into a normalized fraction and an integral power of 2.  */
    98	__MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
    99	
   100	/* X times (two to the EXP power).  */
   101	__MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
   102	
   103	/* Natural logarithm of X.  */
   104	__MATHCALL_VEC (log,, (_Mdouble_ __x));
   105	
   106	/* Base-ten logarithm of X.  */
   107	__MATHCALL_VEC (log10,, (_Mdouble_ __x));
   108	
   109	/* Break VALUE into integral and fractional parts.  */
   110	__MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
   111	
   112	#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C2X)
   113	/* Compute exponent to base ten.  */
   114	__MATHCALL_VEC (exp10,, (_Mdouble_ __x));
   115	#endif
   116	
   117	#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
   118	/* Return exp(X) - 1.  */
   119	__MATHCALL_VEC (expm1,, (_Mdouble_ __x));
   120	
   121	/* Return log(1 + X).  */
   122	__MATHCALL_VEC (log1p,, (_Mdouble_ __x));
   123	
   124	/* Return the base 2 signed integral exponent of X.  */
   125	__MATHCALL (logb,, (_Mdouble_ __x));
   126	#endif
   127	
   128	#ifdef __USE_ISOC99
   129	/* Compute base-2 exponential of X.  */
   130	__MATHCALL_VEC (exp2,, (_Mdouble_ __x));
   131	
   132	/* Compute base-2 logarithm of X.  */
   133	__MATHCALL_VEC (log2,, (_Mdouble_ __x));
   134	#endif
   135	
   136	
   137	/* Power functions.  */
   138	
   139	/* Return X to the Y power.  */
   140	__MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y));
   141	
   142	/* Return the square root of X.  */
   143	__MATHCALL (sqrt,, (_Mdouble_ __x));
   144	
   145	#if defined __USE_XOPEN || defined __USE_ISOC99
   146	/* Return `sqrt(X*X + Y*Y)'.  */
   147	__MATHCALL_VEC (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
   148	#endif
   149	
   150	#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
   151	/* Return the cube root of X.  */
   152	__MATHCALL_VEC (cbrt,, (_Mdouble_ __x));
   153	#endif
   154	
   155	
   156	/* Nearest integer, absolute value, and remainder functions.  */
   157	
   158	/* Smallest integral value not less than X.  */
   159	__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
   160	
   161	/* Absolute value of X.  */
   162	__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
   163	
   164	/* Largest integer not greater than X.  */
   165	__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
   166	
   167	/* Floating-point modulo remainder of X/Y.  */
   168	__MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
   169	
   170	#ifdef __USE_MISC
   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__));
   179	# endif
   180	
   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__));
   185	
   186	/* Return the remainder of X/Y.  */
   187	__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
   188	
   189	
   190	/* Return the fractional part of X after dividing out `ilogb (X)'.  */
   191	__MATHCALL (significand,, (_Mdouble_ __x));
   192	# endif
   193	
   194	#endif /* Use misc.  */
   195	
   196	#ifdef __USE_ISOC99
   197	/* Return X with its signed changed to Y's.  */
   198	__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   199	#endif
   200	
   201	#ifdef __USE_ISOC99
   202	/* Return representation of qNaN for double type.  */
   203	__MATHCALL (nan,, (const char *__tagb));
   204	#endif
   205	
   206	
   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__));
   215	# endif
   216	#endif
   217	
   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_));
   226	#endif
   227	
   228	
   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_));
   234	#endif
   235	
   236	#ifdef __USE_ISOC99
   237	/* True gamma function.  */
   238	__MATHCALL (tgamma,, (_Mdouble_));
   239	#endif
   240	
   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_));
   245	# endif
   246	#endif
   247	
   248	#ifdef __USE_MISC
   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));
   253	#endif
   254	
   255	
   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));
   260	
   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));
   265	# endif
   266	
   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));
   272	# endif
   273	
   274	/* Return the remainder of integer division X / Y with infinite precision.  */
   275	__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
   276	
   277	# ifdef __USE_ISOC99
   278	/* Return X times (2 to the Nth power).  */
   279	__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
   280	# endif
   281	
   282	/* Return the binary exponent of X, which must be nonzero.  */
   283	__MATHDECL (int,ilogb,, (_Mdouble_ __x));
   284	#endif
   285	
   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));
   289	#endif
   290	
   291	#ifdef __USE_ISOC99
   292	/* Return X times (2 to the Nth power).  */
   293	__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
   294	
   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));
   298	
   299	/* Round X to nearest integral value, rounding halfway cases away from
   300	   zero.  */
   301	__MATHCALLX (round,, (_Mdouble_ __x), (__const__));
   302	
   303	/* Round X to the integral value in floating-point format nearest but
   304	   not larger in magnitude.  */
   305	__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
   306	
   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));
   311	
   312	
   313	/* Conversion functions.  */
   314	
   315	/* Round X to nearest integral value according to current rounding
   316	   direction.  */
   317	__MATHDECL (long int,lrint,, (_Mdouble_ __x));
   318	__extension__
   319	__MATHDECL (long long int,llrint,, (_Mdouble_ __x));
   320	
   321	/* Round X to nearest integral value, rounding halfway cases away from
   322	   zero.  */
   323	__MATHDECL (long int,lround,, (_Mdouble_ __x));
   324	__extension__
   325	__MATHDECL (long long int,llround,, (_Mdouble_ __x));
   326	
   327	
   328	/* Return positive difference between X and Y.  */
   329	__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
   330	
   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__));
   334	
   335	/* Return minimum numeric value from X and Y.  */
   336	__MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   337	# endif
   338	
   339	/* Multiply-add function computed as a ternary operation.  */
   340	__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
   341	#endif /* Use ISO C99.  */
   342	
   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__));
   346	
   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));
   351	
   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));
   356	
   357	/* Round X to nearest signed integer value, raising inexact for
   358	   non-integers, with control of rounding direction and width of
   359	   result.  */
   360	__MATHDECL (__intmax_t, fromfpx,, (_Mdouble_ __x, int __round,
   361					   unsigned int __width));
   362	
   363	/* Round X to nearest unsigned integer value, raising inexact for
   364	   non-integers, with control of rounding direction and width of
   365	   result.  */
   366	__MATHDECL (__uintmax_t, ufromfpx,, (_Mdouble_ __x, int __round,
   367					     unsigned int __width));
   368	
   369	/* Canonicalize floating-point representation.  */
   370	__MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));
   371	#endif
   372	
   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__));
   378	
   379	/* Return value with minimum magnitude.  */
   380	__MATHCALLX (fminmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   381	#endif
   382	
   383	#if __GLIBC_USE (ISOC2X)
   384	/* Return maximum value from X and Y.  */
   385	__MATHCALLX (fmaximum,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   386	
   387	/* Return minimum value from X and Y.  */
   388	__MATHCALLX (fminimum,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   389	
   390	/* Return maximum numeric value from X and Y.  */
   391	__MATHCALLX (fmaximum_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   392	
   393	/* Return minimum numeric value from X and Y.  */
   394	__MATHCALLX (fminimum_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   395	
   396	/* Return value with maximum magnitude.  */
   397	__MATHCALLX (fmaximum_mag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   398	
   399	/* Return value with minimum magnitude.  */
   400	__MATHCALLX (fminimum_mag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   401	
   402	/* Return numeric value with maximum magnitude.  */
   403	__MATHCALLX (fmaximum_mag_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   404	
   405	/* Return numeric value with minimum magnitude.  */
   406	__MATHCALLX (fminimum_mag_num,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
   407	#endif
   408	
   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))
   413	     __attribute_pure__;
   414	
   415	/* Total order operation on absolute values.  */
   416	__MATHDECL_1 (int, totalordermag,, (const _Mdouble_ *__x,
   417					    const _Mdouble_ *__y))
   418	     __attribute_pure__;
   419	
   420	/* Get NaN payload.  */
   421	__MATHCALL (getpayload,, (const _Mdouble_ *__x));
   422	
   423	/* Set quiet NaN payload.  */
   424	__MATHDECL_1 (int, setpayload,, (_Mdouble_ *__x, _Mdouble_ __payload));
   425	
   426	/* Set signaling NaN payload.  */
   427	__MATHDECL_1 (int, setpayloadsig,, (_Mdouble_ *__x, _Mdouble_ __payload));
   428	#endif
   429	
   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));
   436	#endif