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