[thirdparty/glibc.git] / math / bits / mathcalls.h

/* Prototype declarations for math functions; helper file for <math.h>.
   Copyright (C) 1996-2016 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 Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* NOTE: Because of the special way this file is used by <math.h>, this
   file must NOT be protected from multiple inclusion as header files
   usually are.

   This file provides prototype declarations for the math functions.
   Most functions are declared using the macro:

   __MATHCALL (NAME,[_r], (ARGS...));

   This means there is a function `NAME' returning `double' and a function
   `NAMEf' returning `float'.  Each place `_Mdouble_' appears in the
   prototype, that is actually `double' in the prototype for `NAME' and
   `float' in the prototype for `NAMEf'.  Reentrant variant functions are
   called `NAME_r' and `NAMEf_r'.

   Functions returning other types like `int' are declared using the macro:

   __MATHDECL (TYPE, NAME,[_r], (ARGS...));

   This is just like __MATHCALL but for a function returning `TYPE'
   instead of `_Mdouble_'.  In all of these cases, there is still
   both a `NAME' and a `NAMEf' that takes `float' arguments.

   Note that there must be no whitespace before the argument passed for
   NAME, to make token pasting work with -traditional.  */

#ifndef _MATH_H
# error "Never include <bits/mathcalls.h> directly; include <math.h> instead."
#endif


/* Trigonometric functions.  */

_Mdouble_BEGIN_NAMESPACE
/* Arc cosine of X.  */
__MATHCALL (acos,, (_Mdouble_ __x));
/* Arc sine of X.  */
__MATHCALL (asin,, (_Mdouble_ __x));
/* Arc tangent of X.  */
__MATHCALL (atan,, (_Mdouble_ __x));
/* Arc tangent of Y/X.  */
__MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x));

/* Cosine of X.  */
__MATHCALL_VEC (cos,, (_Mdouble_ __x));
/* Sine of X.  */
__MATHCALL_VEC (sin,, (_Mdouble_ __x));
/* Tangent of X.  */
__MATHCALL (tan,, (_Mdouble_ __x));

/* Hyperbolic functions.  */

/* Hyperbolic cosine of X.  */
__MATHCALL (cosh,, (_Mdouble_ __x));
/* Hyperbolic sine of X.  */
__MATHCALL (sinh,, (_Mdouble_ __x));
/* Hyperbolic tangent of X.  */
__MATHCALL (tanh,, (_Mdouble_ __x));
_Mdouble_END_NAMESPACE

#ifdef __USE_GNU
/* Cosine and sine of X.  */
__MATHDECL_VEC (void,sincos,,
		(_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
#endif

#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Hyperbolic arc cosine of X.  */
__MATHCALL (acosh,, (_Mdouble_ __x));
/* Hyperbolic arc sine of X.  */
__MATHCALL (asinh,, (_Mdouble_ __x));
/* Hyperbolic arc tangent of X.  */
__MATHCALL (atanh,, (_Mdouble_ __x));
__END_NAMESPACE_C99
#endif

/* Exponential and logarithmic functions.  */

_Mdouble_BEGIN_NAMESPACE
/* Exponential function of X.  */
__MATHCALL_VEC (exp,, (_Mdouble_ __x));

/* Break VALUE into a normalized fraction and an integral power of 2.  */
__MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));

/* X times (two to the EXP power).  */
__MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));

/* Natural logarithm of X.  */
__MATHCALL_VEC (log,, (_Mdouble_ __x));

/* Base-ten logarithm of X.  */
__MATHCALL (log10,, (_Mdouble_ __x));

/* Break VALUE into integral and fractional parts.  */
__MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
_Mdouble_END_NAMESPACE

#if __GLIBC_USE (IEC_60559_FUNCS_EXT)
/* Compute exponent to base ten.  */
__MATHCALL (exp10,, (_Mdouble_ __x));
#endif
#ifdef __USE_GNU
/* Another name occasionally used.  */
__MATHCALL (pow10,, (_Mdouble_ __x));
#endif

#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return exp(X) - 1.  */
__MATHCALL (expm1,, (_Mdouble_ __x));

/* Return log(1 + X).  */
__MATHCALL (log1p,, (_Mdouble_ __x));

/* Return the base 2 signed integral exponent of X.  */
__MATHCALL (logb,, (_Mdouble_ __x));
__END_NAMESPACE_C99
#endif

#ifdef __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Compute base-2 exponential of X.  */
__MATHCALL (exp2,, (_Mdouble_ __x));

/* Compute base-2 logarithm of X.  */
__MATHCALL (log2,, (_Mdouble_ __x));
__END_NAMESPACE_C99
#endif


/* Power functions.  */

_Mdouble_BEGIN_NAMESPACE
/* Return X to the Y power.  */
__MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y));

/* Return the square root of X.  */
__MATHCALL (sqrt,, (_Mdouble_ __x));
_Mdouble_END_NAMESPACE

#if defined __USE_XOPEN || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return `sqrt(X*X + Y*Y)'.  */
__MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
__END_NAMESPACE_C99
#endif

#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return the cube root of X.  */
__MATHCALL (cbrt,, (_Mdouble_ __x));
__END_NAMESPACE_C99
#endif


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

_Mdouble_BEGIN_NAMESPACE
/* Smallest integral value not less than X.  */
__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));

/* Absolute value of X.  */
__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));

/* Largest integer not greater than X.  */
__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));

/* Floating-point modulo remainder of X/Y.  */
__MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));


/* Return 0 if VALUE is finite or NaN, +1 if it
   is +Infinity, -1 if it is -Infinity.  */
__MATHDECL_1 (int,__isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));

/* Return nonzero if VALUE is finite and not NaN.  */
__MATHDECL_1 (int,__finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
_Mdouble_END_NAMESPACE

#ifdef __USE_MISC
# if (!defined __cplusplus \
      || __cplusplus < 201103L /* isinf conflicts with C++11.  */ \
      || __MATH_DECLARING_DOUBLE == 0) /* isinff or isinfl don't.  */
/* Return 0 if VALUE is finite or NaN, +1 if it
   is +Infinity, -1 if it is -Infinity.  */
__MATHDECL_1 (int,isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
# endif

/* Return nonzero if VALUE is finite and not NaN.  */
__MATHDECL_1 (int,finite,, (_Mdouble_ __value)) __attribute__ ((__const__));

/* Return the remainder of X/Y.  */
__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));


/* Return the fractional part of X after dividing out `ilogb (X)'.  */
__MATHCALL (significand,, (_Mdouble_ __x));
#endif /* Use misc.  */

#ifdef __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return X with its signed changed to Y's.  */
__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
__END_NAMESPACE_C99
#endif

#ifdef __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return representation of qNaN for double type.  */
__MATHCALLX (nan,, (const char *__tagb), (__const__));
__END_NAMESPACE_C99
#endif


/* Return nonzero if VALUE is not a number.  */
__MATHDECL_1 (int,__isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));

#if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
# if (!defined __cplusplus \
      || __cplusplus < 201103L /* isnan conflicts with C++11.  */ \
      || __MATH_DECLARING_DOUBLE == 0) /* isnanf or isnanl don't.  */
/* Return nonzero if VALUE is not a number.  */
__MATHDECL_1 (int,isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
# endif
#endif

#if defined __USE_MISC || (defined __USE_XOPEN && __MATH_DECLARING_DOUBLE)
/* Bessel functions.  */
__MATHCALL (j0,, (_Mdouble_));
__MATHCALL (j1,, (_Mdouble_));
__MATHCALL (jn,, (int, _Mdouble_));
__MATHCALL (y0,, (_Mdouble_));
__MATHCALL (y1,, (_Mdouble_));
__MATHCALL (yn,, (int, _Mdouble_));
#endif


#if defined __USE_XOPEN || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Error and gamma functions.  */
__MATHCALL (erf,, (_Mdouble_));
__MATHCALL (erfc,, (_Mdouble_));
__MATHCALL (lgamma,, (_Mdouble_));
__END_NAMESPACE_C99
#endif

#ifdef __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* True gamma function.  */
__MATHCALL (tgamma,, (_Mdouble_));
__END_NAMESPACE_C99
#endif

#if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
/* Obsolete alias for `lgamma'.  */
__MATHCALL (gamma,, (_Mdouble_));
#endif

#ifdef __USE_MISC
/* Reentrant version of lgamma.  This function uses the global variable
   `signgam'.  The reentrant version instead takes a pointer and stores
   the value through it.  */
__MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
#endif


#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__BEGIN_NAMESPACE_C99
/* Return the integer nearest X in the direction of the
   prevailing rounding mode.  */
__MATHCALL (rint,, (_Mdouble_ __x));

/* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
# if defined __USE_ISOC99 && !defined __LDBL_COMPAT
__MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__));
# endif

#if __GLIBC_USE (IEC_60559_BFP_EXT)
/* Return X - epsilon.  */
__MATHCALL (nextdown,, (_Mdouble_ __x));
/* Return X + epsilon.  */
__MATHCALL (nextup,, (_Mdouble_ __x));
# endif

/* Return the remainder of integer divison X / Y with infinite precision.  */
__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));

# ifdef __USE_ISOC99
/* Return X times (2 to the Nth power).  */
__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
# endif

/* Return the binary exponent of X, which must be nonzero.  */
__MATHDECL (int,ilogb,, (_Mdouble_ __x));
#endif

#ifdef __USE_ISOC99
/* Return X times (2 to the Nth power).  */
__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));

/* Round X to integral value in floating-point format using current
   rounding direction, but do not raise inexact exception.  */
__MATHCALL (nearbyint,, (_Mdouble_ __x));

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
__MATHCALLX (round,, (_Mdouble_ __x), (__const__));

/* Round X to the integral value in floating-point format nearest but
   not larger in magnitude.  */
__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));

/* 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.  */
__MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));


/* Conversion functions.  */

/* Round X to nearest integral value according to current rounding
   direction.  */
__MATHDECL (long int,lrint,, (_Mdouble_ __x));
__extension__
__MATHDECL (long long int,llrint,, (_Mdouble_ __x));

/* Round X to nearest integral value, rounding halfway cases away from
   zero.  */
__MATHDECL (long int,lround,, (_Mdouble_ __x));
__extension__
__MATHDECL (long long int,llround,, (_Mdouble_ __x));


/* Return positive difference between X and Y.  */
__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));

/* Return maximum numeric value from X and Y.  */
__MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));

/* Return minimum numeric value from X and Y.  */
__MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));


/* Classify given number.  */
__MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
     __attribute__ ((__const__));

/* Test for negative number.  */
__MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
     __attribute__ ((__const__));


/* Multiply-add function computed as a ternary operation.  */
__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
#endif /* Use ISO C99.  */

#if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
__END_NAMESPACE_C99
#endif

#if __GLIBC_USE (IEC_60559_BFP_EXT)
/* Test equality.  */
__MATHDECL_1 (int, __iseqsig,, (_Mdouble_ __x, _Mdouble_ __y));

/* Test for signaling NaN.  */
__MATHDECL_1 (int, __issignaling,, (_Mdouble_ __value))
     __attribute__ ((__const__));

/* Total order operation.  */
__MATHDECL_1 (int, totalorder,, (_Mdouble_ __x, _Mdouble_ __y))
     __attribute__ ((__const__));

/* Total order operation on absolute values.  */
__MATHDECL_1 (int, totalordermag,, (_Mdouble_ __x, _Mdouble_ __y))
     __attribute__ ((__const__));

/* Canonicalize floating-point representation.  */
__MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));

/* Get NaN payload.  */
__MATHCALL (getpayload,, (const _Mdouble_ *__x));

/* Set quiet NaN payload.  */
__MATHDECL_1 (int, setpayload,, (_Mdouble_ *__x, _Mdouble_ __payload));

/* Set signaling NaN payload.  */
__MATHDECL_1 (int, setpayloadsig,, (_Mdouble_ *__x, _Mdouble_ __payload));
#endif

#if defined __USE_MISC || (defined __USE_XOPEN_EXTENDED \
			   && __MATH_DECLARING_DOUBLE	\
			   && !defined __USE_XOPEN2K8)
/* Return X times (2 to the Nth power).  */
__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
#endif
Commit	Line	Data
f7eac6eb	1	/* Prototype declarations for math functions; helper file for <math.h>.
f7a9f785	2	Copyright (C) 1996-2016 Free Software Foundation, Inc.
2c6fe0bd	3	This file is part of the GNU C Library.
f7eac6eb	4
2c6fe0bd	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	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.
f7eac6eb	9
2c6fe0bd UD	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
41bdb6e2	13	Lesser General Public License for more details.
f7eac6eb	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
f7eac6eb RM	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
af6f3906	40	both a `NAME' and a `NAMEf' that takes `float' arguments.
4bbac92a	41
af6f3906 UD	42	Note that there must be no whitespace before the argument passed for
af6f3906 UD	43	NAME, to make token pasting work with -traditional. */
f7eac6eb RM	44
f7eac6eb RM	45	#ifndef _MATH_H
7a5affeb	46	# error "Never include <bits/mathcalls.h> directly; include <math.h> instead."
f7eac6eb RM	47	#endif
	48
	49
	50	/* Trigonometric functions. */
	51
7a5affeb	52	_Mdouble_BEGIN_NAMESPACE
f7eac6eb RM	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. */
21933112	63	__MATHCALL_VEC (cos,, (_Mdouble_ __x));
f7eac6eb	64	/* Sine of X. */
4b9c2b70	65	__MATHCALL_VEC (sin,, (_Mdouble_ __x));
f7eac6eb RM	66	/* Tangent of X. */
	67	__MATHCALL (tan,, (_Mdouble_ __x));
	68
f7eac6eb RM	69	/* Hyperbolic functions. */
	70
	71	/* Hyperbolic cosine of X. */
	72	__MATHCALL (cosh,, (_Mdouble_ __x));
	73	/* Hyperbolic sine of X. */
	74	__MATHCALL (sinh,, (_Mdouble_ __x));
	75	/* Hyperbolic tangent of X. */
	76	__MATHCALL (tanh,, (_Mdouble_ __x));
7a5affeb UD	77	_Mdouble_END_NAMESPACE
	78
	79	#ifdef __USE_GNU
	80	/* Cosine and sine of X. */
c9a8c526 AS	81	__MATHDECL_VEC (void,sincos,,
c9a8c526 AS	82	(_Mdouble_ __x, _Mdouble_ __sinx, _Mdouble_ __cosx));
7a5affeb	83	#endif
f7eac6eb	84
acd7f096	85	#if defined __USE_XOPEN_EXTENDED \|\| defined __USE_ISOC99
7a5affeb	86	__BEGIN_NAMESPACE_C99
f7eac6eb RM	87	/* Hyperbolic arc cosine of X. */
	88	__MATHCALL (acosh,, (_Mdouble_ __x));
	89	/* Hyperbolic arc sine of X. */
	90	__MATHCALL (asinh,, (_Mdouble_ __x));
	91	/* Hyperbolic arc tangent of X. */
	92	__MATHCALL (atanh,, (_Mdouble_ __x));
7a5affeb	93	__END_NAMESPACE_C99
f7eac6eb RM	94	#endif
	95
	96	/* Exponential and logarithmic functions. */
	97
7a5affeb	98	_Mdouble_BEGIN_NAMESPACE
6d52618b	99	/* Exponential function of X. */
9c02f663	100	__MATHCALL_VEC (exp,, (_Mdouble_ __x));
f7eac6eb RM	101
f7eac6eb RM	102	/* Break VALUE into a normalized fraction and an integral power of 2. */
afd4eb37	103	__MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent));
f7eac6eb RM	104
f7eac6eb RM	105	/* X times (two to the EXP power). */
afd4eb37	106	__MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent));
f7eac6eb RM	107
f7eac6eb RM	108	/* Natural logarithm of X. */
6af25acc	109	__MATHCALL_VEC (log,, (_Mdouble_ __x));
f7eac6eb RM	110
	111	/* Base-ten logarithm of X. */
	112	__MATHCALL (log10,, (_Mdouble_ __x));
	113
377a515b	114	/* Break VALUE into integral and fractional parts. */
9c89fca6	115	__MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2));
7a5affeb UD	116	_Mdouble_END_NAMESPACE
7a5affeb UD	117
412cb261 JM	118	#if __GLIBC_USE (IEC_60559_FUNCS_EXT)
412cb261 JM	119	/* Compute exponent to base ten. */
7a5affeb	120	__MATHCALL (exp10,, (_Mdouble_ __x));
412cb261 JM	121	#endif
412cb261 JM	122	#ifdef __USE_GNU
7a5affeb UD	123	/* Another name occasionally used. */
	124	__MATHCALL (pow10,, (_Mdouble_ __x));
	125	#endif
377a515b	126
acd7f096	127	#if defined __USE_XOPEN_EXTENDED \|\| defined __USE_ISOC99
7a5affeb	128	__BEGIN_NAMESPACE_C99
f7eac6eb RM	129	/* Return exp(X) - 1. */
	130	__MATHCALL (expm1,, (_Mdouble_ __x));
	131
	132	/* Return log(1 + X). */
	133	__MATHCALL (log1p,, (_Mdouble_ __x));
2c6fe0bd UD	134
	135	/* Return the base 2 signed integral exponent of X. */
	136	__MATHCALL (logb,, (_Mdouble_ __x));
7a5affeb	137	__END_NAMESPACE_C99
f7eac6eb RM	138	#endif
f7eac6eb RM	139
ec751a23	140	#ifdef __USE_ISOC99
7a5affeb	141	__BEGIN_NAMESPACE_C99
377a515b UD	142	/* Compute base-2 exponential of X. */
	143	__MATHCALL (exp2,, (_Mdouble_ __x));
	144
	145	/* Compute base-2 logarithm of X. */
	146	__MATHCALL (log2,, (_Mdouble_ __x));
7a5affeb	147	__END_NAMESPACE_C99
377a515b	148	#endif
f7eac6eb RM	149
	150
	151	/* Power functions. */
	152
7a5affeb	153	_Mdouble_BEGIN_NAMESPACE
f7eac6eb	154	/* Return X to the Y power. */
c10b9b13	155	__MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y));
f7eac6eb RM	156
	157	/* Return the square root of X. */
	158	__MATHCALL (sqrt,, (_Mdouble_ __x));
7a5affeb	159	_Mdouble_END_NAMESPACE
f7eac6eb	160
acd7f096	161	#if defined __USE_XOPEN \|\| defined __USE_ISOC99
7a5affeb	162	__BEGIN_NAMESPACE_C99
377a515b UD	163	/* Return `sqrt(XX + YY)'. */
377a515b UD	164	__MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
7a5affeb	165	__END_NAMESPACE_C99
e918a7fe	166	#endif
377a515b	167
acd7f096	168	#if defined __USE_XOPEN_EXTENDED \|\| defined __USE_ISOC99
7a5affeb	169	__BEGIN_NAMESPACE_C99
f7eac6eb RM	170	/* Return the cube root of X. */
f7eac6eb RM	171	__MATHCALL (cbrt,, (_Mdouble_ __x));
7a5affeb	172	__END_NAMESPACE_C99
f7eac6eb RM	173	#endif
	174
	175
	176	/* Nearest integer, absolute value, and remainder functions. */
	177
7a5affeb	178	_Mdouble_BEGIN_NAMESPACE
f7eac6eb	179	/* Smallest integral value not less than X. */
f4efd068	180	__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
f7eac6eb RM	181
f7eac6eb RM	182	/* Absolute value of X. */
3e5f5557	183	__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
f7eac6eb RM	184
f7eac6eb RM	185	/* Largest integer not greater than X. */
f4efd068	186	__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
f7eac6eb RM	187
	188	/* Floating-point modulo remainder of X/Y. */
	189	__MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
	190
	191
bfce746a UD	192	/* Return 0 if VALUE is finite or NaN, +1 if it
	193	is +Infinity, -1 if it is -Infinity. */
	194	__MATHDECL_1 (int,__isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
	195
a1648746 UD	196	/* Return nonzero if VALUE is finite and not NaN. */
a1648746 UD	197	__MATHDECL_1 (int,__finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
7a5affeb	198	_Mdouble_END_NAMESPACE
a1648746	199
f7eac6eb	200	#ifdef __USE_MISC
3c47c83a CD	201	# if (!defined __cplusplus \
	202	\|\| __cplusplus < 201103L /* isinf conflicts with C++11. */ \
	203	\|\| __MATH_DECLARING_DOUBLE == 0) /* isinff or isinfl don't. */
f7eac6eb RM	204	/* Return 0 if VALUE is finite or NaN, +1 if it
f7eac6eb RM	205	is +Infinity, -1 if it is -Infinity. */
bfce746a	206	__MATHDECL_1 (int,isinf,, (_Mdouble_ __value)) __attribute__ ((__const__));
d9b965fa	207	# endif
f7eac6eb	208
f7eac6eb	209	/* Return nonzero if VALUE is finite and not NaN. */
a1648746	210	__MATHDECL_1 (int,finite,, (_Mdouble_ __value)) __attribute__ ((__const__));
f7eac6eb	211
f7eac6eb RM	212	/* Return the remainder of X/Y. */
	213	__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
	214
f7eac6eb	215
2c6fe0bd UD	216	/* Return the fractional part of X after dividing out `ilogb (X)'. */
	217	__MATHCALL (significand,, (_Mdouble_ __x));
	218	#endif /* Use misc. */
f7eac6eb	219
acd7f096	220	#ifdef __USE_ISOC99
7a5affeb	221	__BEGIN_NAMESPACE_C99
377a515b	222	/* Return X with its signed changed to Y's. */
3e5f5557	223	__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
7a5affeb	224	__END_NAMESPACE_C99
377a515b UD	225	#endif
377a515b UD	226
ec751a23	227	#ifdef __USE_ISOC99
7a5affeb	228	__BEGIN_NAMESPACE_C99
67e971f1	229	/* Return representation of qNaN for double type. */
a784e502	230	__MATHCALLX (nan,, (const char *__tagb), (__const__));
7a5affeb	231	__END_NAMESPACE_C99
377a515b	232	#endif
2c6fe0bd	233
2c6fe0bd	234
68337808	235	/* Return nonzero if VALUE is not a number. */
a1648746	236	__MATHDECL_1 (int,__isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
68337808	237
de20571d	238	#if defined __USE_MISC \|\| (defined __USE_XOPEN && !defined __USE_XOPEN2K)
3c47c83a CD	239	# if (!defined __cplusplus \
	240	\|\| __cplusplus < 201103L /* isnan conflicts with C++11. */ \
	241	\|\| __MATH_DECLARING_DOUBLE == 0) /* isnanf or isnanl don't. */
2c6fe0bd	242	/* Return nonzero if VALUE is not a number. */
a1648746	243	__MATHDECL_1 (int,isnan,, (_Mdouble_ __value)) __attribute__ ((__const__));
d9b965fa	244	# endif
de20571d	245	#endif
f7eac6eb	246
1f11365a	247	#if defined __USE_MISC \|\| (defined __USE_XOPEN && __MATH_DECLARING_DOUBLE)
377a515b UD	248	/* Bessel functions. */
	249	__MATHCALL (j0,, (_Mdouble_));
	250	__MATHCALL (j1,, (_Mdouble_));
	251	__MATHCALL (jn,, (int, _Mdouble_));
	252	__MATHCALL (y0,, (_Mdouble_));
	253	__MATHCALL (y1,, (_Mdouble_));
	254	__MATHCALL (yn,, (int, _Mdouble_));
	255	#endif
f7eac6eb RM	256
f7eac6eb RM	257
acd7f096	258	#if defined __USE_XOPEN \|\| defined __USE_ISOC99
7a5affeb	259	__BEGIN_NAMESPACE_C99
7d6a8338	260	/* Error and gamma functions. */
f7eac6eb RM	261	__MATHCALL (erf,, (_Mdouble_));
f7eac6eb RM	262	__MATHCALL (erfc,, (_Mdouble_));
f7eac6eb	263	__MATHCALL (lgamma,, (_Mdouble_));
7a5affeb	264	__END_NAMESPACE_C99
0ed99ce4 UD	265	#endif
	266
	267	#ifdef __USE_ISOC99
7a5affeb UD	268	__BEGIN_NAMESPACE_C99
7a5affeb UD	269	/* True gamma function. */
e852e889	270	__MATHCALL (tgamma,, (_Mdouble_));
7a5affeb	271	__END_NAMESPACE_C99
e852e889 UD	272	#endif
e852e889 UD	273
de20571d	274	#if defined __USE_MISC \|\| (defined __USE_XOPEN && !defined __USE_XOPEN2K)
7d6a8338	275	/* Obsolete alias for `lgamma'. */
e852e889	276	__MATHCALL (gamma,, (_Mdouble_));
d705269e	277	#endif
f7eac6eb	278
19361cb7	279	#ifdef __USE_MISC
7d6a8338 UD	280	/* Reentrant version of lgamma. This function uses the global variable
	281	`signgam'. The reentrant version instead takes a pointer and stores
	282	the value through it. */
	283	__MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
f7eac6eb RM	284	#endif
f7eac6eb RM	285
2c6fe0bd	286
acd7f096	287	#if defined __USE_XOPEN_EXTENDED \|\| defined __USE_ISOC99
7a5affeb	288	__BEGIN_NAMESPACE_C99
2c6fe0bd UD	289	/* Return the integer nearest X in the direction of the
	290	prevailing rounding mode. */
	291	__MATHCALL (rint,, (_Mdouble_ __x));
	292
2c6fe0bd	293	/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
3e5f5557	294	__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
c6251f03	295	# if defined __USE_ISOC99 && !defined __LDBL_COMPAT
36fe9ac9	296	__MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__));
bfce746a	297	# endif
2c6fe0bd	298
bf91be88	299	#if __GLIBC_USE (IEC_60559_BFP_EXT)
41a359e2 RS	300	/* Return X - epsilon. */
	301	__MATHCALL (nextdown,, (_Mdouble_ __x));
	302	/* Return X + epsilon. */
	303	__MATHCALL (nextup,, (_Mdouble_ __x));
	304	# endif
	305
2c6fe0bd UD	306	/* Return the remainder of integer divison X / Y with infinite precision. */
2c6fe0bd UD	307	__MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
2c6fe0bd	308
acd7f096	309	# ifdef __USE_ISOC99
d705269e	310	/* Return X times (2 to the Nth power). */
dfd2257a	311	__MATHCALL (scalbn,, (_Mdouble_ __x, int __n));
0ed99ce4	312	# endif
d705269e UD	313
	314	/* Return the binary exponent of X, which must be nonzero. */
	315	__MATHDECL (int,ilogb,, (_Mdouble_ __x));
377a515b UD	316	#endif
377a515b UD	317
ec751a23	318	#ifdef __USE_ISOC99
dfd2257a UD	319	/* Return X times (2 to the Nth power). */
	320	__MATHCALL (scalbln,, (_Mdouble_ __x, long int __n));
	321
4caef86c	322	/* Round X to integral value in floating-point format using current
377a515b UD	323	rounding direction, but do not raise inexact exception. */
	324	__MATHCALL (nearbyint,, (_Mdouble_ __x));
	325
	326	/* Round X to nearest integral value, rounding halfway cases away from
	327	zero. */
27caaf41	328	__MATHCALLX (round,, (_Mdouble_ __x), (__const__));
377a515b UD	329
	330	/* Round X to the integral value in floating-point format nearest but
	331	not larger in magnitude. */
3e5f5557	332	__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
377a515b UD	333
	334	/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
	335	and magnitude congruent `mod 2^n' to the magnitude of the integral
	336	quotient x/y, with n >= 3. */
	337	__MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
	338
	339
dfd2257a UD	340	/* Conversion functions. */
	341
	342	/* Round X to nearest integral value according to current rounding
	343	direction. */
af6f3906	344	__MATHDECL (long int,lrint,, (_Mdouble_ __x));
828beb13	345	__extension__
af6f3906	346	__MATHDECL (long long int,llrint,, (_Mdouble_ __x));
dfd2257a UD	347
	348	/* Round X to nearest integral value, rounding halfway cases away from
	349	zero. */
af6f3906	350	__MATHDECL (long int,lround,, (_Mdouble_ __x));
828beb13	351	__extension__
af6f3906	352	__MATHDECL (long long int,llround,, (_Mdouble_ __x));
dfd2257a UD	353
dfd2257a UD	354
377a515b UD	355	/* Return positive difference between X and Y. */
	356	__MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
	357
4cca6b86	358	/* Return maximum numeric value from X and Y. */
e58ef0f2	359	__MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
377a515b	360
4cca6b86	361	/* Return minimum numeric value from X and Y. */
e58ef0f2	362	__MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
377a515b UD	363
	364
	365	/* Classify given number. */
3e5f5557 UD	366	__MATHDECL_1 (int, __fpclassify,, (_Mdouble_ __value))
3e5f5557 UD	367	__attribute__ ((__const__));
377a515b UD	368
377a515b UD	369	/* Test for negative number. */
3e5f5557 UD	370	__MATHDECL_1 (int, __signbit,, (_Mdouble_ __value))
3e5f5557 UD	371	__attribute__ ((__const__));
dfd2257a UD	372
	373
	374	/* Multiply-add function computed as a ternary operation. */
	375	__MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
d36421fa RM	376	#endif /* Use ISO C99. */
d36421fa RM	377
acd7f096	378	#if defined __USE_XOPEN_EXTENDED \|\| defined __USE_ISOC99
7a5affeb	379	__END_NAMESPACE_C99
d36421fa	380	#endif
7a5affeb	381
bf91be88	382	#if __GLIBC_USE (IEC_60559_BFP_EXT)
1e7c8fcc JM	383	/* Test equality. */
	384	__MATHDECL_1 (int, __iseqsig,, (_Mdouble_ __x, _Mdouble_ __y));
	385
57267616 TS	386	/* Test for signaling NaN. */
	387	__MATHDECL_1 (int, __issignaling,, (_Mdouble_ __value))
	388	__attribute__ ((__const__));
5e9d98a3 JM	389
	390	/* Total order operation. */
	391	__MATHDECL_1 (int, totalorder,, (_Mdouble_ __x, _Mdouble_ __y))
	392	__attribute__ ((__const__));
cc6a8d74 JM	393
	394	/* Total order operation on absolute values. */
	395	__MATHDECL_1 (int, totalordermag,, (_Mdouble_ __x, _Mdouble_ __y))
	396	__attribute__ ((__const__));
f8e8b8ed	397
eaf5ad0b JM	398	/* Canonicalize floating-point representation. */
	399	__MATHDECL_1 (int, canonicalize,, (_Mdouble_ __cx, const _Mdouble_ __x));
	400
f8e8b8ed JM	401	/* Get NaN payload. */
f8e8b8ed JM	402	__MATHCALL (getpayload,, (const _Mdouble_ *__x));
eb3c12c7 JM	403
	404	/* Set quiet NaN payload. */
	405	__MATHDECL_1 (int, setpayload,, (_Mdouble_ *__x, _Mdouble_ __payload));
457663a7 JM	406
	407	/* Set signaling NaN payload. */
	408	__MATHDECL_1 (int, setpayloadsig,, (_Mdouble_ *__x, _Mdouble_ __payload));
57267616 TS	409	#endif
57267616 TS	410
de20571d JM	411	#if defined __USE_MISC \|\| (defined __USE_XOPEN_EXTENDED \
	412	&& __MATH_DECLARING_DOUBLE \
	413	&& !defined __USE_XOPEN2K8)
7a5affeb UD	414	/* Return X times (2 to the Nth power). */
7a5affeb UD	415	__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
d36421fa	416	#endif