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

/* Declarations for math functions.
   Copyright (C) 1991-1993,1995-1999,2001,2002 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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 *	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>

/* Get machine-dependent NAN value (returned for some domain errors).  */
#ifdef	 __USE_ISOC99
# include <bits/nan.h>
#endif
/* 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_
# ifdef __STDC__
#  define __MATH_PRECNAME(name,r) name##f##r
# else
#  define __MATH_PRECNAME(name,r) name/**/f/**/r
# endif
# 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 (__STDC__ - 0 || __GNUC__ - 0) && !defined __NO_LONG_DOUBLE_MATH
/* 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_
#  ifdef __STDC__
#   define __MATH_PRECNAME(name,r) name##l##r
#  else
#   define __MATH_PRECNAME(name,r) name/**/l/**/r
#  endif
#  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

# endif /* __STDC__ || __GNUC__ */

#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.  */
#if __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 FP_NAN
    FP_INFINITE,
# define FP_INFINITE FP_INFINITE
    FP_ZERO,
# define FP_ZERO FP_ZERO
    FP_SUBNORMAL,
# define FP_SUBNORMAL FP_SUBNORMAL
    FP_NORMAL
# define FP_NORMAL 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 is 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.  */

#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.7182818284590452353602874713526625L  /* e */
# define M_LOG2El	1.4426950408889634073599246810018921L  /* log_2 e */
# define M_LOG10El	0.4342944819032518276511289189166051L  /* log_10 e */
# define M_LN2l		0.6931471805599453094172321214581766L  /* log_e 2 */
# define M_LN10l	2.3025850929940456840179914546843642L  /* log_e 10 */
# define M_PIl		3.1415926535897932384626433832795029L  /* pi */
# define M_PI_2l	1.5707963267948966192313216916397514L  /* pi/2 */
# define M_PI_4l	0.7853981633974483096156608458198757L  /* pi/4 */
# define M_1_PIl	0.3183098861837906715377675267450287L  /* 1/pi */
# define M_2_PIl	0.6366197723675813430755350534900574L  /* 2/pi */
# define M_2_SQRTPIl	1.1283791670955125738961589031215452L  /* 2/sqrt(pi) */
# define M_SQRT2l	1.4142135623730950488016887242096981L  /* sqrt(2) */
# define M_SQRT1_2l	0.7071067811865475244008443621048490L  /* 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

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


#if __USE_ISOC99
/* ISO C99 defines some macros to compare number while taking care
   for unordered numbers.  Since many FPUs provide special
   instructions to support these operations and these tests are
   defined in <bits/mathinline.h>, we define the generic macros at
   this late point and only if they are not defined yet.  */

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