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

/* Declarations for math functions.
   Copyright (C) 1991-2015 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/>.  */

/*
 *	ISO C99 Standard: 7.12 Mathematics	<math.h>
 */

#ifndef	_MATH_H
#define	_MATH_H	1

#include <features.h>

__BEGIN_DECLS

/* Get machine-dependent HUGE_VAL value (returned on overflow).
   On all IEEE754 machines, this is +Infinity.  */
#include <bits/huge_val.h>
#ifdef __USE_ISOC99
# include <bits/huge_valf.h>
# include <bits/huge_vall.h>

/* Get machine-dependent INFINITY value.  */
# include <bits/inf.h>

/* Get machine-dependent NAN value (returned for some domain errors).  */
# include <bits/nan.h>
#endif /* __USE_ISOC99 */

/* Get general and ISO C99 specific information.  */
#include <bits/mathdef.h>

/* The file <bits/mathcalls.h> contains the prototypes for all the
   actual math functions.  These macros are used for those prototypes,
   so we can easily declare each function as both `name' and `__name',
   and can declare the float versions `namef' and `__namef'.  */

#define __MATHCALL(function,suffix, args)	\
  __MATHDECL (_Mdouble_,function,suffix, args)
#define __MATHDECL(type, function,suffix, args) \
  __MATHDECL_1(type, function,suffix, args); \
  __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
#define __MATHCALLX(function,suffix, args, attrib)	\
  __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
#define __MATHDECLX(type, function,suffix, args, attrib) \
  __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
  __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
#define __MATHDECL_1(type, function,suffix, args) \
  extern type __MATH_PRECNAME(function,suffix) args __THROW

#define _Mdouble_		double
#define __MATH_PRECNAME(name,r)	__CONCAT(name,r)
#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
#define _Mdouble_END_NAMESPACE   __END_NAMESPACE_STD
#include <bits/mathcalls.h>
#undef	_Mdouble_
#undef _Mdouble_BEGIN_NAMESPACE
#undef _Mdouble_END_NAMESPACE
#undef	__MATH_PRECNAME

#ifdef __USE_ISOC99


/* Include the file of declarations again, this time using `float'
   instead of `double' and appending f to each function name.  */

# ifndef _Mfloat_
#  define _Mfloat_		float
# endif
# define _Mdouble_		_Mfloat_
# define __MATH_PRECNAME(name,r) name##f##r
# define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
# define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
# include <bits/mathcalls.h>
# undef	_Mdouble_
# undef _Mdouble_BEGIN_NAMESPACE
# undef _Mdouble_END_NAMESPACE
# undef	__MATH_PRECNAME

# if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
     || defined __LDBL_COMPAT \
     || defined _LIBC_TEST
#  ifdef __LDBL_COMPAT

#   ifdef __USE_ISOC99
extern float __nldbl_nexttowardf (float __x, long double __y)
				  __THROW __attribute__ ((__const__));
#    ifdef __REDIRECT_NTH
extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
			     __nldbl_nexttowardf)
     __attribute__ ((__const__));
extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
			      nextafter) __attribute__ ((__const__));
extern long double __REDIRECT_NTH (nexttowardl,
				   (long double __x, long double __y),
				   nextafter) __attribute__ ((__const__));
#    endif
#   endif

#   undef __MATHDECL_1
#   define __MATHDECL_2(type, function,suffix, args, alias) \
  extern type __REDIRECT_NTH(__MATH_PRECNAME(function,suffix), \
			     args, alias)
#   define __MATHDECL_1(type, function,suffix, args) \
  __MATHDECL_2(type, function,suffix, args, __CONCAT(function,suffix))
#  endif

/* Include the file of declarations again, this time using `long double'
   instead of `double' and appending l to each function name.  */

#  ifndef _Mlong_double_
#   define _Mlong_double_	long double
#  endif
#  define _Mdouble_		_Mlong_double_
#  define __MATH_PRECNAME(name,r) name##l##r
#  define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
#  define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
#  define __MATH_DECLARE_LDOUBLE   1
#  include <bits/mathcalls.h>
#  undef _Mdouble_
#  undef _Mdouble_BEGIN_NAMESPACE
#  undef _Mdouble_END_NAMESPACE
#  undef __MATH_PRECNAME

# endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */

#endif	/* Use ISO C99.  */
#undef	__MATHDECL_1
#undef	__MATHDECL
#undef	__MATHCALL


#if defined __USE_MISC || defined __USE_XOPEN
/* This variable is used by `gamma' and `lgamma'.  */
extern int signgam;
#endif


/* ISO C99 defines some generic macros which work on any data type.  */
#ifdef __USE_ISOC99

/* Get the architecture specific values describing the floating-point
   evaluation.  The following symbols will get defined:

    float_t	floating-point type at least as wide as `float' used
		to evaluate `float' expressions
    double_t	floating-point type at least as wide as `double' used
		to evaluate `double' expressions

    FLT_EVAL_METHOD
		Defined to
		  0	if `float_t' is `float' and `double_t' is `double'
		  1	if `float_t' and `double_t' are `double'
		  2	if `float_t' and `double_t' are `long double'
		  else	`float_t' and `double_t' are unspecified

    INFINITY	representation of the infinity value of type `float'

    FP_FAST_FMA
    FP_FAST_FMAF
    FP_FAST_FMAL
		If defined it indicates that the `fma' function
		generally executes about as fast as a multiply and an add.
		This macro is defined only iff the `fma' function is
		implemented directly with a hardware multiply-add instructions.

    FP_ILOGB0	Expands to a value returned by `ilogb (0.0)'.
    FP_ILOGBNAN	Expands to a value returned by `ilogb (NAN)'.

    DECIMAL_DIG	Number of decimal digits supported by conversion between
		decimal and all internal floating-point formats.

*/

/* All floating-point numbers can be put in one of these categories.  */
enum
  {
    FP_NAN =
# define FP_NAN 0
      FP_NAN,
    FP_INFINITE =
# define FP_INFINITE 1
      FP_INFINITE,
    FP_ZERO =
# define FP_ZERO 2
      FP_ZERO,
    FP_SUBNORMAL =
# define FP_SUBNORMAL 3
      FP_SUBNORMAL,
    FP_NORMAL =
# define FP_NORMAL 4
      FP_NORMAL
  };

/* Return number of classification appropriate for X.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define fpclassify(x) \
     (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x))
# else
#  define fpclassify(x) \
     (sizeof (x) == sizeof (float)					      \
      ? __fpclassifyf (x)						      \
      : sizeof (x) == sizeof (double)					      \
      ? __fpclassify (x) : __fpclassifyl (x))
# endif

/* Return nonzero value if sign of X is negative.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define signbit(x) \
     (sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
# else
#  define signbit(x) \
     (sizeof (x) == sizeof (float)					      \
      ? __signbitf (x)							      \
      : sizeof (x) == sizeof (double)					      \
      ? __signbit (x) : __signbitl (x))
# endif

/* Return nonzero value if X is not +-Inf or NaN.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define isfinite(x) \
     (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
# else
#  define isfinite(x) \
     (sizeof (x) == sizeof (float)					      \
      ? __finitef (x)							      \
      : sizeof (x) == sizeof (double)					      \
      ? __finite (x) : __finitel (x))
# endif

/* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
# define isnormal(x) (fpclassify (x) == FP_NORMAL)

/* Return nonzero value if X is a NaN.  We could use `fpclassify' but
   we already have this functions `__isnan' and it is faster.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define isnan(x) \
     (sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
# else
#  define isnan(x) \
     (sizeof (x) == sizeof (float)					      \
      ? __isnanf (x)							      \
      : sizeof (x) == sizeof (double)					      \
      ? __isnan (x) : __isnanl (x))
# endif

/* Return nonzero value if X is positive or negative infinity.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define isinf(x) \
     (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
# else
#  define isinf(x) \
     (sizeof (x) == sizeof (float)					      \
      ? __isinff (x)							      \
      : sizeof (x) == sizeof (double)					      \
      ? __isinf (x) : __isinfl (x))
# endif

/* Bitmasks for the math_errhandling macro.  */
# define MATH_ERRNO	1	/* errno set by math functions.  */
# define MATH_ERREXCEPT	2	/* Exceptions raised by math functions.  */

/* By default all functions support both errno and exception handling.
   In gcc's fast math mode and if inline functions are defined this
   might not be true.  */
# ifndef __FAST_MATH__
#  define math_errhandling	(MATH_ERRNO | MATH_ERREXCEPT)
# endif

#endif /* Use ISO C99.  */

#ifdef __USE_GNU
/* Return nonzero value if X is a signaling NaN.  */
# ifdef __NO_LONG_DOUBLE_MATH
#  define issignaling(x) \
     (sizeof (x) == sizeof (float) ? __issignalingf (x) : __issignaling (x))
# else
#  define issignaling(x) \
     (sizeof (x) == sizeof (float)					      \
      ? __issignalingf (x)						      \
      : sizeof (x) == sizeof (double)					      \
      ? __issignaling (x) : __issignalingl (x))
# endif
#endif /* Use GNU.  */

#ifdef	__USE_MISC
/* Support for various different standard error handling behaviors.  */
typedef enum
{
  _IEEE_ = -1,	/* According to IEEE 754/IEEE 854.  */
  _SVID_,	/* According to System V, release 4.  */
  _XOPEN_,	/* Nowadays also Unix98.  */
  _POSIX_,
  _ISOC_	/* Actually this is ISO C99.  */
} _LIB_VERSION_TYPE;

/* This variable can be changed at run-time to any of the values above to
   affect floating point error handling behavior (it may also be necessary
   to change the hardware FPU exception settings).  */
extern _LIB_VERSION_TYPE _LIB_VERSION;
#endif


#ifdef __USE_MISC
/* In SVID error handling, `matherr' is called with this description
   of the exceptional condition.

   We have a problem when using C++ since `exception' is a reserved
   name in C++.  */
# ifdef __cplusplus
struct __exception
# else
struct exception
# endif
  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };

# ifdef __cplusplus
extern int matherr (struct __exception *__exc) throw ();
# else
extern int matherr (struct exception *__exc);
# endif

# define X_TLOSS	1.41484755040568800000e+16

/* Types of exceptions in the `type' field.  */
# define DOMAIN		1
# define SING		2
# define OVERFLOW	3
# define UNDERFLOW	4
# define TLOSS		5
# define PLOSS		6

/* SVID mode specifies returning this large value instead of infinity.  */
# define HUGE		3.40282347e+38F

#else	/* !Misc.  */

# ifdef __USE_XOPEN
/* X/Open wants another strange constant.  */
#  define MAXFLOAT	3.40282347e+38F
# endif

#endif	/* Misc.  */


/* Some useful constants.  */
#if defined __USE_MISC || defined __USE_XOPEN
# define M_E		2.7182818284590452354	/* e */
# define M_LOG2E	1.4426950408889634074	/* log_2 e */
# define M_LOG10E	0.43429448190325182765	/* log_10 e */
# define M_LN2		0.69314718055994530942	/* log_e 2 */
# define M_LN10		2.30258509299404568402	/* log_e 10 */
# define M_PI		3.14159265358979323846	/* pi */
# define M_PI_2		1.57079632679489661923	/* pi/2 */
# define M_PI_4		0.78539816339744830962	/* pi/4 */
# define M_1_PI		0.31830988618379067154	/* 1/pi */
# define M_2_PI		0.63661977236758134308	/* 2/pi */
# define M_2_SQRTPI	1.12837916709551257390	/* 2/sqrt(pi) */
# define M_SQRT2	1.41421356237309504880	/* sqrt(2) */
# define M_SQRT1_2	0.70710678118654752440	/* 1/sqrt(2) */
#endif

/* The above constants are not adequate for computation using `long double's.
   Therefore we provide as an extension constants with similar names as a
   GNU extension.  Provide enough digits for the 128-bit IEEE quad.  */
#ifdef __USE_GNU
# define M_El		2.718281828459045235360287471352662498L /* e */
# define M_LOG2El	1.442695040888963407359924681001892137L /* log_2 e */
# define M_LOG10El	0.434294481903251827651128918916605082L /* log_10 e */
# define M_LN2l		0.693147180559945309417232121458176568L /* log_e 2 */
# define M_LN10l	2.302585092994045684017991454684364208L /* log_e 10 */
# define M_PIl		3.141592653589793238462643383279502884L /* pi */
# define M_PI_2l	1.570796326794896619231321691639751442L /* pi/2 */
# define M_PI_4l	0.785398163397448309615660845819875721L /* pi/4 */
# define M_1_PIl	0.318309886183790671537767526745028724L /* 1/pi */
# define M_2_PIl	0.636619772367581343075535053490057448L /* 2/pi */
# define M_2_SQRTPIl	1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
# define M_SQRT2l	1.414213562373095048801688724209698079L /* sqrt(2) */
# define M_SQRT1_2l	0.707106781186547524400844362104849039L /* 1/sqrt(2) */
#endif


/* When compiling in strict ISO C compatible mode we must not use the
   inline functions since they, among other things, do not set the
   `errno' variable correctly.  */
#if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
# define __NO_MATH_INLINES	1
#endif

#if defined __USE_ISOC99 && __GNUC_PREREQ(2,97)
/* ISO C99 defines some macros to compare number while taking care for
   unordered numbers.  Many FPUs provide special instructions to support
   these operations.  Generic support in GCC for these as builtins went
   in before 3.0.0, but not all cpus added their patterns.  We define
   versions that use the builtins here, and <bits/mathinline.h> will
   undef/redefine as appropriate for the specific GCC version in use.  */
# define isgreater(x, y)	__builtin_isgreater(x, y)
# define isgreaterequal(x, y)	__builtin_isgreaterequal(x, y)
# define isless(x, y)		__builtin_isless(x, y)
# define islessequal(x, y)	__builtin_islessequal(x, y)
# define islessgreater(x, y)	__builtin_islessgreater(x, y)
# define isunordered(u, v)	__builtin_isunordered(u, v)
#endif

/* Get machine-dependent inline versions (if there are any).  */
#ifdef __USE_EXTERN_INLINES
# include <bits/mathinline.h>
#endif

/* Define special entry points to use when the compiler got told to
   only expect finite results.  */
#if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0
# include <bits/math-finite.h>
#endif

#ifdef __USE_ISOC99
/* If we've still got undefined comparison macros, provide defaults.  */

/* Return nonzero value if X is greater than Y.  */
# ifndef isgreater
#  define isgreater(x, y) \
  (__extension__							      \
   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
      !isunordered (__x, __y) && __x > __y; }))
# endif

/* Return nonzero value if X is greater than or equal to Y.  */
# ifndef isgreaterequal
#  define isgreaterequal(x, y) \
  (__extension__							      \
   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
      !isunordered (__x, __y) && __x >= __y; }))
# endif

/* Return nonzero value if X is less than Y.  */
# ifndef isless
#  define isless(x, y) \
  (__extension__							      \
   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
      !isunordered (__x, __y) && __x < __y; }))
# endif

/* Return nonzero value if X is less than or equal to Y.  */
# ifndef islessequal
#  define islessequal(x, y) \
  (__extension__							      \
   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
      !isunordered (__x, __y) && __x <= __y; }))
# endif

/* Return nonzero value if either X is less than Y or Y is less than X.  */
# ifndef islessgreater
#  define islessgreater(x, y) \
  (__extension__							      \
   ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
      !isunordered (__x, __y) && (__x < __y || __y < __x); }))
# endif

/* Return nonzero value if arguments are unordered.  */
# ifndef isunordered
#  define isunordered(u, v) \
  (__extension__							      \
   ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v);			      \
      fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; }))
# endif

#endif

__END_DECLS


#endif /* math.h  */
Commit	Line	Data
f7eac6eb	1	/* Declarations for math functions.
b168057a	2	Copyright (C) 1991-2015 Free Software Foundation, Inc.
ba1ffaa1	3	This file is part of the GNU C Library.
28f540f4	4
ba1ffaa1	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.
28f540f4	9
ba1ffaa1 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.
28f540f4	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/>. */
28f540f4 RM	18
28f540f4 RM	19	/*
d1646309	20	* ISO C99 Standard: 7.12 Mathematics <math.h>
28f540f4 RM	21	*/
	22
	23	#ifndef _MATH_H
28f540f4	24	#define _MATH_H 1
5107cf1d	25
28f540f4 RM	26	#include <features.h>
	27
	28	__BEGIN_DECLS
	29
f7eac6eb RM	30	/* Get machine-dependent HUGE_VAL value (returned on overflow).
f7eac6eb RM	31	On all IEEE754 machines, this is +Infinity. */
5107cf1d	32	#include <bits/huge_val.h>
a86573f4 RH	33	#ifdef __USE_ISOC99
	34	# include <bits/huge_valf.h>
	35	# include <bits/huge_vall.h>
	36
	37	/* Get machine-dependent INFINITY value. */
	38	# include <bits/inf.h>
28f540f4 RM	39
28f540f4 RM	40	/* Get machine-dependent NAN value (returned for some domain errors). */
478b92f0	41	# include <bits/nan.h>
a86573f4 RH	42	#endif /* __USE_ISOC99 */
a86573f4 RH	43
ec751a23	44	/* Get general and ISO C99 specific information. */
d76bd17f	45	#include <bits/mathdef.h>
28f540f4	46
5107cf1d UD	47	/* The file <bits/mathcalls.h> contains the prototypes for all the
	48	actual math functions. These macros are used for those prototypes,
	49	so we can easily declare each function as both `name' and `__name',
f7eac6eb RM	50	and can declare the float versions `namef' and `__namef'. */
	51
	52	#define __MATHCALL(function,suffix, args) \
377a515b	53	__MATHDECL (_Mdouble_,function,suffix, args)
f7eac6eb RM	54	#define __MATHDECL(type, function,suffix, args) \
f7eac6eb RM	55	__MATHDECL_1(type, function,suffix, args); \
377a515b	56	__MATHDECL_1(type, __CONCAT(__,function),suffix, args)
3e5f5557 UD	57	#define __MATHCALLX(function,suffix, args, attrib) \
	58	__MATHDECLX (_Mdouble_,function,suffix, args, attrib)
	59	#define __MATHDECLX(type, function,suffix, args, attrib) \
	60	__MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
	61	__MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
f7eac6eb	62	#define __MATHDECL_1(type, function,suffix, args) \
c1422e5b	63	extern type __MATH_PRECNAME(function,suffix) args __THROW
f7eac6eb	64
0ac5ae23	65	#define _Mdouble_ double
377a515b	66	#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
0ac5ae23 UD	67	#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
0ac5ae23 UD	68	#define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD
5107cf1d	69	#include <bits/mathcalls.h>
f7eac6eb	70	#undef _Mdouble_
7a5affeb UD	71	#undef _Mdouble_BEGIN_NAMESPACE
7a5affeb UD	72	#undef _Mdouble_END_NAMESPACE
f7eac6eb RM	73	#undef __MATH_PRECNAME
f7eac6eb RM	74
acd7f096	75	#ifdef __USE_ISOC99
76060ec0	76
999493cb RM	77
999493cb RM	78	/* Include the file of declarations again, this time using `float'
f7eac6eb RM	79	instead of `double' and appending f to each function name. */
f7eac6eb RM	80
fe0ec73e UD	81	# ifndef _Mfloat_
fe0ec73e UD	82	# define _Mfloat_ float
478b92f0	83	# endif
0ac5ae23	84	# define _Mdouble_ _Mfloat_
7071ad79	85	# define __MATH_PRECNAME(name,r) name##f##r
7a5affeb UD	86	# define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
7a5affeb UD	87	# define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
478b92f0 UD	88	# include <bits/mathcalls.h>
478b92f0 UD	89	# undef _Mdouble_
7a5affeb UD	90	# undef _Mdouble_BEGIN_NAMESPACE
7a5affeb UD	91	# undef _Mdouble_END_NAMESPACE
478b92f0	92	# undef __MATH_PRECNAME
76060ec0	93
7071ad79	94	# if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
dc6fe23b WN	95	\|\| defined __LDBL_COMPAT \
dc6fe23b WN	96	\|\| defined _LIBC_TEST
c6251f03 RM	97	# ifdef __LDBL_COMPAT
c6251f03 RM	98
7b943af6	99	# ifdef __USE_ISOC99
c6251f03	100	extern float __nldbl_nexttowardf (float __x, long double __y)
42247128	101	__THROW __attribute__ ((__const__));
c6251f03 RM	102	# ifdef __REDIRECT_NTH
	103	extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
	104	__nldbl_nexttowardf)
	105	__attribute__ ((__const__));
	106	extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
	107	nextafter) __attribute__ ((__const__));
42247128 RM	108	extern long double __REDIRECT_NTH (nexttowardl,
	109	(long double __x, long double __y),
	110	nextafter) __attribute__ ((__const__));
c6251f03 RM	111	# endif
	112	# endif
	113
c6251f03 RM	114	# undef __MATHDECL_1
c6251f03 RM	115	# define __MATHDECL_2(type, function,suffix, args, alias) \
42247128 RM	116	extern type __REDIRECT_NTH(__MATH_PRECNAME(function,suffix), \
42247128 RM	117	args, alias)
c6251f03 RM	118	# define __MATHDECL_1(type, function,suffix, args) \
	119	__MATHDECL_2(type, function,suffix, args, __CONCAT(function,suffix))
	120	# endif
	121
998832a4 AS	122	/* Include the file of declarations again, this time using `long double'
	123	instead of `double' and appending l to each function name. */
	124
fe0ec73e UD	125	# ifndef _Mlong_double_
	126	# define _Mlong_double_ long double
	127	# endif
0ac5ae23	128	# define _Mdouble_ _Mlong_double_
7071ad79	129	# define __MATH_PRECNAME(name,r) name##l##r
7a5affeb UD	130	# define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
7a5affeb UD	131	# define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
0ac5ae23	132	# define __MATH_DECLARE_LDOUBLE 1
fe0ec73e UD	133	# include <bits/mathcalls.h>
fe0ec73e UD	134	# undef _Mdouble_
0ac5ae23 UD	135	# undef _Mdouble_BEGIN_NAMESPACE
0ac5ae23 UD	136	# undef _Mdouble_END_NAMESPACE
fe0ec73e UD	137	# undef __MATH_PRECNAME
fe0ec73e UD	138
7071ad79	139	# endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) \|\| __LDBL_COMPAT */
377a515b	140
acd7f096	141	#endif /* Use ISO C99. */
4cca6b86 UD	142	#undef __MATHDECL_1
	143	#undef __MATHDECL
	144	#undef __MATHCALL
	145
	146
00d8bc81	147	#if defined __USE_MISC \|\| defined __USE_XOPEN
4cca6b86 UD	148	/* This variable is used by `gamma' and `lgamma'. */
	149	extern int signgam;
	150	#endif
377a515b UD	151
377a515b UD	152
ec751a23	153	/* ISO C99 defines some generic macros which work on any data type. */
638bed90	154	#ifdef __USE_ISOC99
377a515b	155
63551311 UD	156	/* Get the architecture specific values describing the floating-point
	157	evaluation. The following symbols will get defined:
	158
fe0ec73e	159	float_t floating-point type at least as wide as `float' used
63551311	160	to evaluate `float' expressions
fe0ec73e	161	double_t floating-point type at least as wide as `double' used
63551311 UD	162	to evaluate `double' expressions
63551311 UD	163
fe0ec73e	164	FLT_EVAL_METHOD
63551311 UD	165	Defined to
	166	0 if `float_t' is `float' and `double_t' is `double'
	167	1 if `float_t' and `double_t' are `double'
	168	2 if `float_t' and `double_t' are `long double'
	169	else `float_t' and `double_t' are unspecified
	170
fe0ec73e	171	INFINITY representation of the infinity value of type `float'
dfd2257a	172
fe0ec73e UD	173	FP_FAST_FMA
	174	FP_FAST_FMAF
	175	FP_FAST_FMAL
3081378b	176	If defined it indicates that the `fma' function
dfd2257a UD	177	generally executes about as fast as a multiply and an add.
	178	This macro is defined only iff the `fma' function is
	179	implemented directly with a hardware multiply-add instructions.
	180
	181	FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'.
	182	FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
	183
fe0ec73e UD	184	DECIMAL_DIG Number of decimal digits supported by conversion between
	185	decimal and all internal floating-point formats.
	186
63551311	187	*/
63551311	188
377a515b UD	189	/* All floating-point numbers can be put in one of these categories. */
	190	enum
	191	{
0155d5b2 JM	192	FP_NAN =
	193	# define FP_NAN 0
	194	FP_NAN,
	195	FP_INFINITE =
	196	# define FP_INFINITE 1
	197	FP_INFINITE,
	198	FP_ZERO =
	199	# define FP_ZERO 2
	200	FP_ZERO,
	201	FP_SUBNORMAL =
	202	# define FP_SUBNORMAL 3
	203	FP_SUBNORMAL,
	204	FP_NORMAL =
	205	# define FP_NORMAL 4
	206	FP_NORMAL
377a515b UD	207	};
	208
	209	/* Return number of classification appropriate for X. */
68337808 UD	210	# ifdef __NO_LONG_DOUBLE_MATH
68337808 UD	211	# define fpclassify(x) \
48252123	212	(sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x))
68337808 UD	213	# else
68337808 UD	214	# define fpclassify(x) \
15daa639 UD	215	(sizeof (x) == sizeof (float) \
	216	? __fpclassifyf (x) \
	217	: sizeof (x) == sizeof (double) \
	218	? __fpclassify (x) : __fpclassifyl (x))
68337808	219	# endif
377a515b UD	220
377a515b UD	221	/* Return nonzero value if sign of X is negative. */
68337808 UD	222	# ifdef __NO_LONG_DOUBLE_MATH
68337808 UD	223	# define signbit(x) \
48252123	224	(sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
68337808 UD	225	# else
68337808 UD	226	# define signbit(x) \
15daa639 UD	227	(sizeof (x) == sizeof (float) \
	228	? __signbitf (x) \
	229	: sizeof (x) == sizeof (double) \
	230	? __signbit (x) : __signbitl (x))
68337808	231	# endif
377a515b UD	232
377a515b UD	233	/* Return nonzero value if X is not +-Inf or NaN. */
68337808 UD	234	# ifdef __NO_LONG_DOUBLE_MATH
68337808 UD	235	# define isfinite(x) \
48252123	236	(sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
68337808 UD	237	# else
68337808 UD	238	# define isfinite(x) \
15daa639 UD	239	(sizeof (x) == sizeof (float) \
	240	? __finitef (x) \
	241	: sizeof (x) == sizeof (double) \
	242	? __finite (x) : __finitel (x))
68337808	243	# endif
377a515b UD	244
377a515b UD	245	/* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */
478b92f0	246	# define isnormal(x) (fpclassify (x) == FP_NORMAL)
377a515b UD	247
	248	/* Return nonzero value if X is a NaN. We could use `fpclassify' but
	249	we already have this functions `__isnan' and it is faster. */
68337808 UD	250	# ifdef __NO_LONG_DOUBLE_MATH
68337808 UD	251	# define isnan(x) \
48252123	252	(sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
68337808 UD	253	# else
68337808 UD	254	# define isnan(x) \
15daa639 UD	255	(sizeof (x) == sizeof (float) \
	256	? __isnanf (x) \
	257	: sizeof (x) == sizeof (double) \
	258	? __isnan (x) : __isnanl (x))
68337808	259	# endif
28f540f4	260
0e012e87	261	/* Return nonzero value if X is positive or negative infinity. */
68337808 UD	262	# ifdef __NO_LONG_DOUBLE_MATH
68337808 UD	263	# define isinf(x) \
48252123	264	(sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
68337808 UD	265	# else
68337808 UD	266	# define isinf(x) \
15daa639 UD	267	(sizeof (x) == sizeof (float) \
	268	? __isinff (x) \
	269	: sizeof (x) == sizeof (double) \
	270	? __isinf (x) : __isinfl (x))
68337808	271	# endif
bfce746a	272
12b64309 UD	273	/* Bitmasks for the math_errhandling macro. */
	274	# define MATH_ERRNO 1 /* errno set by math functions. */
	275	# define MATH_ERREXCEPT 2 /* Exceptions raised by math functions. */
	276
7b943af6 UD	277	/* By default all functions support both errno and exception handling.
	278	In gcc's fast math mode and if inline functions are defined this
	279	might not be true. */
	280	# ifndef __FAST_MATH__
	281	# define math_errhandling (MATH_ERRNO \| MATH_ERREXCEPT)
	282	# endif
	283
ec751a23	284	#endif /* Use ISO C99. */
377a515b	285
57267616 TS	286	#ifdef __USE_GNU
	287	/* Return nonzero value if X is a signaling NaN. */
	288	# ifdef __NO_LONG_DOUBLE_MATH
	289	# define issignaling(x) \
	290	(sizeof (x) == sizeof (float) ? __issignalingf (x) : __issignaling (x))
	291	# else
	292	# define issignaling(x) \
	293	(sizeof (x) == sizeof (float) \
	294	? __issignalingf (x) \
	295	: sizeof (x) == sizeof (double) \
	296	? __issignaling (x) : __issignalingl (x))
	297	# endif
	298	#endif /* Use GNU. */
	299
28f540f4	300	#ifdef __USE_MISC
f7eac6eb	301	/* Support for various different standard error handling behaviors. */
b9337b6a UD	302	typedef enum
	303	{
	304	_IEEE_ = -1, /* According to IEEE 754/IEEE 854. */
	305	_SVID_, /* According to System V, release 4. */
	306	_XOPEN_, /* Nowadays also Unix98. */
	307	_POSIX_,
ec751a23	308	_ISOC_ /* Actually this is ISO C99. */
b9337b6a	309	} _LIB_VERSION_TYPE;
28f540f4	310
f7eac6eb RM	311	/* This variable can be changed at run-time to any of the values above to
	312	affect floating point error handling behavior (it may also be necessary
	313	to change the hardware FPU exception settings). */
	314	extern _LIB_VERSION_TYPE _LIB_VERSION;
28f540f4 RM	315	#endif
	316
	317
498afc54	318	#ifdef __USE_MISC
f7eac6eb	319	/* In SVID error handling, `matherr' is called with this description
2f6d1f1b UD	320	of the exceptional condition.
2f6d1f1b UD	321
fe0ec73e UD	322	We have a problem when using C++ since `exception' is a reserved
fe0ec73e UD	323	name in C++. */
478b92f0	324	# ifdef __cplusplus
ceb2d9aa	325	struct __exception
478b92f0	326	# else
f7eac6eb	327	struct exception
478b92f0	328	# endif
f7eac6eb RM	329	{
	330	int type;
	331	char *name;
	332	double arg1;
	333	double arg2;
	334	double retval;
	335	};
28f540f4	336
478b92f0	337	# ifdef __cplusplus
c1422e5b	338	extern int matherr (struct __exception *__exc) throw ();
478b92f0	339	# else
c1422e5b	340	extern int matherr (struct exception *__exc);
478b92f0	341	# endif
28f540f4	342
478b92f0	343	# define X_TLOSS 1.41484755040568800000e+16
28f540f4	344
f7eac6eb	345	/* Types of exceptions in the `type' field. */
478b92f0 UD	346	# define DOMAIN 1
	347	# define SING 2
	348	# define OVERFLOW 3
	349	# define UNDERFLOW 4
	350	# define TLOSS 5
	351	# define PLOSS 6
28f540f4	352
f7eac6eb	353	/* SVID mode specifies returning this large value instead of infinity. */
12b64309	354	# define HUGE 3.40282347e+38F
28f540f4	355
acd7f096	356	#else /* !Misc. */
377a515b	357
478b92f0	358	# ifdef __USE_XOPEN
377a515b	359	/* X/Open wants another strange constant. */
12b64309	360	# define MAXFLOAT 3.40282347e+38F
478b92f0	361	# endif
377a515b	362
acd7f096	363	#endif /* Misc. */
28f540f4	364
28f540f4	365
28f540f4	366	/* Some useful constants. */
498afc54	367	#if defined __USE_MISC \|\| defined __USE_XOPEN
0a614877 UD	368	# define M_E 2.7182818284590452354 /* e */
	369	# define M_LOG2E 1.4426950408889634074 /* log_2 e */
	370	# define M_LOG10E 0.43429448190325182765 /* log_10 e */
	371	# define M_LN2 0.69314718055994530942 /* log_e 2 */
	372	# define M_LN10 2.30258509299404568402 /* log_e 10 */
	373	# define M_PI 3.14159265358979323846 /* pi */
	374	# define M_PI_2 1.57079632679489661923 /* pi/2 */
	375	# define M_PI_4 0.78539816339744830962 /* pi/4 */
	376	# define M_1_PI 0.31830988618379067154 /* 1/pi */
	377	# define M_2_PI 0.63661977236758134308 /* 2/pi */
	378	# define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
	379	# define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
	380	# define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
714a562f UD	381	#endif
714a562f UD	382
0a614877 UD	383	/* The above constants are not adequate for computation using `long double's.
0a614877 UD	384	Therefore we provide as an extension constants with similar names as a
9a24f906	385	GNU extension. Provide enough digits for the 128-bit IEEE quad. */
0a614877	386	#ifdef __USE_GNU
2d10d547 JM	387	# define M_El 2.718281828459045235360287471352662498L /* e */
	388	# define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
	389	# define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
	390	# define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */
	391	# define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */
	392	# define M_PIl 3.141592653589793238462643383279502884L /* pi */
	393	# define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
	394	# define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
	395	# define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
	396	# define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
	397	# define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
	398	# define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
	399	# define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
0a614877	400	#endif
710f7bab	401
28f540f4	402
00bc5db0 UD	403	/* When compiling in strict ISO C compatible mode we must not use the
	404	inline functions since they, among other things, do not set the
	405	`errno' variable correctly. */
	406	#if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
	407	# define __NO_MATH_INLINES 1
	408	#endif
	409
638bed90	410	#if defined __USE_ISOC99 && __GNUC_PREREQ(2,97)
f4c024d1 UD	411	/* ISO C99 defines some macros to compare number while taking care for
	412	unordered numbers. Many FPUs provide special instructions to support
	413	these operations. Generic support in GCC for these as builtins went
	414	in before 3.0.0, but not all cpus added their patterns. We define
	415	versions that use the builtins here, and <bits/mathinline.h> will
	416	undef/redefine as appropriate for the specific GCC version in use. */
	417	# define isgreater(x, y) __builtin_isgreater(x, y)
	418	# define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
	419	# define isless(x, y) __builtin_isless(x, y)
	420	# define islessequal(x, y) __builtin_islessequal(x, y)
	421	# define islessgreater(x, y) __builtin_islessgreater(x, y)
	422	# define isunordered(u, v) __builtin_isunordered(u, v)
	423	#endif
	424
4d585333	425	/* Get machine-dependent inline versions (if there are any). */
0c6cee5d	426	#ifdef __USE_EXTERN_INLINES
478b92f0	427	# include <bits/mathinline.h>
4d585333 RM	428	#endif
4d585333 RM	429
0ac5ae23 UD	430	/* Define special entry points to use when the compiler got told to
	431	only expect finite results. */
	432	#if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0
	433	# include <bits/math-finite.h>
	434	#endif
	435
638bed90	436	#ifdef __USE_ISOC99
f4c024d1	437	/* If we've still got undefined comparison macros, provide defaults. */
ae1025be UD	438
	439	/* Return nonzero value if X is greater than Y. */
	440	# ifndef isgreater
55c14926 UD	441	# define isgreater(x, y) \
	442	(__extension__ \
	443	({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
	444	!isunordered (__x, __y) && __x > __y; }))
ae1025be UD	445	# endif
	446
	447	/* Return nonzero value if X is greater than or equal to Y. */
	448	# ifndef isgreaterequal
55c14926 UD	449	# define isgreaterequal(x, y) \
	450	(__extension__ \
	451	({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
	452	!isunordered (__x, __y) && __x >= __y; }))
ae1025be UD	453	# endif
	454
	455	/* Return nonzero value if X is less than Y. */
	456	# ifndef isless
55c14926 UD	457	# define isless(x, y) \
	458	(__extension__ \
	459	({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
	460	!isunordered (__x, __y) && __x < __y; }))
ae1025be UD	461	# endif
	462
	463	/* Return nonzero value if X is less than or equal to Y. */
	464	# ifndef islessequal
55c14926 UD	465	# define islessequal(x, y) \
	466	(__extension__ \
	467	({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
	468	!isunordered (__x, __y) && __x <= __y; }))
ae1025be UD	469	# endif
	470
	471	/* Return nonzero value if either X is less than Y or Y is less than X. */
	472	# ifndef islessgreater
	473	# define islessgreater(x, y) \
55c14926 UD	474	(__extension__ \
	475	({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
	476	!isunordered (__x, __y) && (__x < __y \|\| __y < __x); }))
ae1025be UD	477	# endif
	478
	479	/* Return nonzero value if arguments are unordered. */
	480	# ifndef isunordered
d111572f	481	# define isunordered(u, v) \
55c14926	482	(__extension__ \
d111572f UD	483	({ __typeof__(u) __u = (u); __typeof__(v) __v = (v); \
d111572f UD	484	fpclassify (__u) == FP_NAN \|\| fpclassify (__v) == FP_NAN; }))
ae1025be UD	485	# endif
	486
	487	#endif
	488
4d585333 RM	489	__END_DECLS
	490
	491
28f540f4	492	#endif /* math.h */