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