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

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

#if defined __USE_MISC || defined __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
#  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 misc or 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_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_SVID
/* 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	/* !SVID */

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

#endif	/* SVID */


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