1// -*- C++ -*- C forwarding header. 2 3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4// Free Software Foundation, Inc. 5// 6// This file is part of the GNU ISO C++ Library. This library is free 7// software; you can redistribute it and/or modify it under the 8// terms of the GNU General Public License as published by the 9// Free Software Foundation; either version 2, or (at your option) 10// any later version. 11 12// This library is distributed in the hope that it will be useful, 13// but WITHOUT ANY WARRANTY; without even the implied warranty of 14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15// GNU General Public License for more details. 16 17// You should have received a copy of the GNU General Public License along 18// with this library; see the file COPYING. If not, write to the Free 19// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 20// USA. 21 22// As a special exception, you may use this file as part of a free software 23// library without restriction. Specifically, if other files instantiate 24// templates or use macros or inline functions from this file, or you compile 25// this file and link it with other files to produce an executable, this 26// file does not by itself cause the resulting executable to be covered by 27// the GNU General Public License. This exception does not however 28// invalidate any other reasons why the executable file might be covered by 29// the GNU General Public License. 30 31/** @file include/cmath 32 * This is a Standard C++ Library file. You should @c #include this file 33 * in your programs, rather than any of the "*.h" implementation files. 34 * 35 * This is the C++ version of the Standard C Library header @c math.h, 36 * and its contents are (mostly) the same as that header, but are all 37 * contained in the namespace @c std (except for names which are defined 38 * as macros in C). 39 */ 40 41// 42// ISO C++ 14882: 26.5 C library 43// 44 45#ifndef _GLIBCXX_CMATH 46#define _GLIBCXX_CMATH 1 47 48#pragma GCC system_header 49 50#include <bits/c++config.h> 51#include <bits/cpp_type_traits.h> 52#include <ext/type_traits.h> 53 54#include <math.h> 55 56// Get rid of those macros defined in <math.h> in lieu of real functions. 57#undef abs 58#undef div 59#undef acos 60#undef asin 61#undef atan 62#undef atan2 63#undef ceil 64#undef cos 65#undef cosh 66#undef exp 67#undef fabs 68#undef floor 69#undef fmod 70#undef frexp 71#undef ldexp 72#undef log 73#undef log10 74#undef modf 75#undef pow 76#undef sin 77#undef sinh 78#undef sqrt 79#undef tan 80#undef tanh 81 82_GLIBCXX_BEGIN_NAMESPACE(std) 83 84 // Forward declaration of a helper function. This really should be 85 // an `exported' forward declaration. 86 template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int); 87 88 inline double 89 abs(double __x) 90 { return __builtin_fabs(__x); } 91 92 inline float 93 abs(float __x) 94 { return __builtin_fabsf(__x); } 95 96 inline long double 97 abs(long double __x) 98 { return __builtin_fabsl(__x); } 99 100 using ::acos; 101 102 inline float 103 acos(float __x) 104 { return __builtin_acosf(__x); } 105 106 inline long double 107 acos(long double __x) 108 { return __builtin_acosl(__x); } 109 110 template<typename _Tp> 111 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 112 double>::__type 113 acos(_Tp __x) 114 { return __builtin_acos(__x); } 115 116 using ::asin; 117 118 inline float 119 asin(float __x) 120 { return __builtin_asinf(__x); } 121 122 inline long double 123 asin(long double __x) 124 { return __builtin_asinl(__x); } 125 126 template<typename _Tp> 127 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 128 double>::__type 129 asin(_Tp __x) 130 { return __builtin_asin(__x); } 131 132 using ::atan; 133 134 inline float 135 atan(float __x) 136 { return __builtin_atanf(__x); } 137 138 inline long double 139 atan(long double __x) 140 { return __builtin_atanl(__x); } 141 142 template<typename _Tp> 143 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 144 double>::__type 145 atan(_Tp __x) 146 { return __builtin_atan(__x); } 147 148 using ::atan2; 149 150 inline float 151 atan2(float __y, float __x) 152 { return __builtin_atan2f(__y, __x); } 153 154 inline long double 155 atan2(long double __y, long double __x) 156 { return __builtin_atan2l(__y, __x); } 157 158 template<typename _Tp, typename _Up> 159 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value 160 && __is_integer<_Up>::__value, 161 double>::__type 162 atan2(_Tp __y, _Up __x) 163 { return __builtin_atan2(__y, __x); } 164 165 using ::ceil; 166 167 inline float 168 ceil(float __x) 169 { return __builtin_ceilf(__x); } 170 171 inline long double 172 ceil(long double __x) 173 { return __builtin_ceill(__x); } 174 175 template<typename _Tp> 176 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 177 double>::__type 178 ceil(_Tp __x) 179 { return __builtin_ceil(__x); } 180 181 using ::cos; 182 183 inline float 184 cos(float __x) 185 { return __builtin_cosf(__x); } 186 187 inline long double 188 cos(long double __x) 189 { return __builtin_cosl(__x); } 190 191 template<typename _Tp> 192 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 193 double>::__type 194 cos(_Tp __x) 195 { return __builtin_cos(__x); } 196 197 using ::cosh; 198 199 inline float 200 cosh(float __x) 201 { return __builtin_coshf(__x); } 202 203 inline long double 204 cosh(long double __x) 205 { return __builtin_coshl(__x); } 206 207 template<typename _Tp> 208 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 209 double>::__type 210 cosh(_Tp __x) 211 { return __builtin_cosh(__x); } 212 213 using ::exp; 214 215 inline float 216 exp(float __x) 217 { return __builtin_expf(__x); } 218 219 inline long double 220 exp(long double __x) 221 { return __builtin_expl(__x); } 222 223 template<typename _Tp> 224 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 225 double>::__type 226 exp(_Tp __x) 227 { return __builtin_exp(__x); } 228 229 using ::fabs; 230 231 inline float 232 fabs(float __x) 233 { return __builtin_fabsf(__x); } 234 235 inline long double 236 fabs(long double __x) 237 { return __builtin_fabsl(__x); } 238 239 template<typename _Tp> 240 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 241 double>::__type 242 fabs(_Tp __x) 243 { return __builtin_fabs(__x); } 244 245 using ::floor; 246 247 inline float 248 floor(float __x) 249 { return __builtin_floorf(__x); } 250 251 inline long double 252 floor(long double __x) 253 { return __builtin_floorl(__x); } 254 255 template<typename _Tp> 256 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 257 double>::__type 258 floor(_Tp __x) 259 { return __builtin_floor(__x); } 260 261 using ::fmod; 262 263 inline float 264 fmod(float __x, float __y) 265 { return __builtin_fmodf(__x, __y); } 266 267 inline long double 268 fmod(long double __x, long double __y) 269 { return __builtin_fmodl(__x, __y); } 270 271 using ::frexp; 272 273 inline float 274 frexp(float __x, int* __exp) 275 { return __builtin_frexpf(__x, __exp); } 276 277 inline long double 278 frexp(long double __x, int* __exp) 279 { return __builtin_frexpl(__x, __exp); } 280 281 template<typename _Tp> 282 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 283 double>::__type 284 frexp(_Tp __x, int* __exp) 285 { return __builtin_frexp(__x, __exp); } 286 287 using ::ldexp; 288 289 inline float 290 ldexp(float __x, int __exp) 291 { return __builtin_ldexpf(__x, __exp); } 292 293 inline long double 294 ldexp(long double __x, int __exp) 295 { return __builtin_ldexpl(__x, __exp); } 296 297 template<typename _Tp> 298 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 299 double>::__type 300 ldexp(_Tp __x, int __exp) 301 { return __builtin_ldexp(__x, __exp); } 302 303 using ::log; 304 305 inline float 306 log(float __x) 307 { return __builtin_logf(__x); } 308 309 inline long double 310 log(long double __x) 311 { return __builtin_logl(__x); } 312 313 template<typename _Tp> 314 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 315 double>::__type 316 log(_Tp __x) 317 { return __builtin_log(__x); } 318 319 using ::log10; 320 321 inline float 322 log10(float __x) 323 { return __builtin_log10f(__x); } 324 325 inline long double 326 log10(long double __x) 327 { return __builtin_log10l(__x); } 328 329 template<typename _Tp> 330 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 331 double>::__type 332 log10(_Tp __x) 333 { return __builtin_log10(__x); } 334 335 using ::modf; 336 337 inline float 338 modf(float __x, float* __iptr) 339 { return __builtin_modff(__x, __iptr); } 340 341 inline long double 342 modf(long double __x, long double* __iptr) 343 { return __builtin_modfl(__x, __iptr); } 344 345 template<typename _Tp> 346 inline _Tp 347 __pow_helper(_Tp __x, int __n) 348 { 349 return __n < 0 350 ? _Tp(1)/__cmath_power(__x, -__n) 351 : __cmath_power(__x, __n); 352 } 353 354 using ::pow; 355 356 inline float 357 pow(float __x, float __y) 358 { return __builtin_powf(__x, __y); } 359 360 inline long double 361 pow(long double __x, long double __y) 362 { return __builtin_powl(__x, __y); } 363 364 inline double 365 pow(double __x, int __i) 366 { return __builtin_powi(__x, __i); } 367 368 inline float 369 pow(float __x, int __n) 370 { return __builtin_powif(__x, __n); } 371 372 inline long double 373 pow(long double __x, int __n) 374 { return __builtin_powil(__x, __n); } 375 376 using ::sin; 377 378 inline float 379 sin(float __x) 380 { return __builtin_sinf(__x); } 381 382 inline long double 383 sin(long double __x) 384 { return __builtin_sinl(__x); } 385 386 template<typename _Tp> 387 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 388 double>::__type 389 sin(_Tp __x) 390 { return __builtin_sin(__x); } 391 392 using ::sinh; 393 394 inline float 395 sinh(float __x) 396 { return __builtin_sinhf(__x); } 397 398 inline long double 399 sinh(long double __x) 400 { return __builtin_sinhl(__x); } 401 402 template<typename _Tp> 403 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 404 double>::__type 405 sinh(_Tp __x) 406 { return __builtin_sinh(__x); } 407 408 using ::sqrt; 409 410 inline float 411 sqrt(float __x) 412 { return __builtin_sqrtf(__x); } 413 414 inline long double 415 sqrt(long double __x) 416 { return __builtin_sqrtl(__x); } 417 418 template<typename _Tp> 419 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 420 double>::__type 421 sqrt(_Tp __x) 422 { return __builtin_sqrt(__x); } 423 424 using ::tan; 425 426 inline float 427 tan(float __x) 428 { return __builtin_tanf(__x); } 429 430 inline long double 431 tan(long double __x) 432 { return __builtin_tanl(__x); } 433 434 template<typename _Tp> 435 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 436 double>::__type 437 tan(_Tp __x) 438 { return __builtin_tan(__x); } 439 440 using ::tanh; 441 442 inline float 443 tanh(float __x) 444 { return __builtin_tanhf(__x); } 445 446 inline long double 447 tanh(long double __x) 448 { return __builtin_tanhl(__x); } 449 450 template<typename _Tp> 451 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 452 double>::__type 453 tanh(_Tp __x) 454 { return __builtin_tanh(__x); } 455 456_GLIBCXX_END_NAMESPACE 457 458#if _GLIBCXX_USE_C99_MATH 459#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC 460// These are possible macros imported from C99-land. For strict 461// conformance, remove possible C99-injected names from the global 462// namespace, and sequester them in the __gnu_cxx extension namespace. 463 464_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) 465 466 template<typename _Tp> 467 inline int 468 __capture_fpclassify(_Tp __f) { return fpclassify(__f); } 469 470 template<typename _Tp> 471 inline int 472 __capture_isfinite(_Tp __f) { return isfinite(__f); } 473 474 template<typename _Tp> 475 inline int 476 __capture_isinf(_Tp __f) { return isinf(__f); } 477 478 template<typename _Tp> 479 inline int 480 __capture_isnan(_Tp __f) { return isnan(__f); } 481 482 template<typename _Tp> 483 inline int 484 __capture_isnormal(_Tp __f) { return isnormal(__f); } 485 486 template<typename _Tp> 487 inline int 488 __capture_signbit(_Tp __f) { return signbit(__f); } 489 490 template<typename _Tp> 491 inline int 492 __capture_isgreater(_Tp __f1, _Tp __f2) 493 { return isgreater(__f1, __f2); } 494 495 template<typename _Tp> 496 inline int 497 __capture_isgreaterequal(_Tp __f1, _Tp __f2) 498 { return isgreaterequal(__f1, __f2); } 499 500 template<typename _Tp> 501 inline int 502 __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); } 503 504 template<typename _Tp> 505 inline int 506 __capture_islessequal(_Tp __f1, _Tp __f2) 507 { return islessequal(__f1, __f2); } 508 509 template<typename _Tp> 510 inline int 511 __capture_islessgreater(_Tp __f1, _Tp __f2) 512 { return islessgreater(__f1, __f2); } 513 514 template<typename _Tp> 515 inline int 516 __capture_isunordered(_Tp __f1, _Tp __f2) 517 { return isunordered(__f1, __f2); } 518 519_GLIBCXX_END_NAMESPACE 520 521// Only undefine the C99 FP macros, if actually captured for namespace movement 522#undef fpclassify 523#undef isfinite 524#undef isinf 525#undef isnan 526#undef isnormal 527#undef signbit 528#undef isgreater 529#undef isgreaterequal 530#undef isless 531#undef islessequal 532#undef islessgreater 533#undef isunordered 534 535_GLIBCXX_BEGIN_NAMESPACE(std) 536 537 template<typename _Tp> 538 inline int 539 fpclassify(_Tp __f) { return ::__gnu_cxx::__capture_fpclassify(__f); } 540 541 template<typename _Tp> 542 inline int 543 isfinite(_Tp __f) { return ::__gnu_cxx::__capture_isfinite(__f); } 544 545 template<typename _Tp> 546 inline int 547 isinf(_Tp __f) { return ::__gnu_cxx::__capture_isinf(__f); } 548 549 template<typename _Tp> 550 inline int 551 isnan(_Tp __f) { return ::__gnu_cxx::__capture_isnan(__f); } 552 553 template<typename _Tp> 554 inline int 555 isnormal(_Tp __f) { return ::__gnu_cxx::__capture_isnormal(__f); } 556 557 template<typename _Tp> 558 inline int 559 signbit(_Tp __f) { return ::__gnu_cxx::__capture_signbit(__f); } 560 561 template<typename _Tp> 562 inline int 563 isgreater(_Tp __f1, _Tp __f2) 564 { return ::__gnu_cxx::__capture_isgreater(__f1, __f2); } 565 566 template<typename _Tp> 567 inline int 568 isgreaterequal(_Tp __f1, _Tp __f2) 569 { return ::__gnu_cxx::__capture_isgreaterequal(__f1, __f2); } 570 571 template<typename _Tp> 572 inline int 573 isless(_Tp __f1, _Tp __f2) 574 { return ::__gnu_cxx::__capture_isless(__f1, __f2); } 575 576 template<typename _Tp> 577 inline int 578 islessequal(_Tp __f1, _Tp __f2) 579 { return ::__gnu_cxx::__capture_islessequal(__f1, __f2); } 580 581 template<typename _Tp> 582 inline int 583 islessgreater(_Tp __f1, _Tp __f2) 584 { return ::__gnu_cxx::__capture_islessgreater(__f1, __f2); } 585 586 template<typename _Tp> 587 inline int 588 isunordered(_Tp __f1, _Tp __f2) 589 { return ::__gnu_cxx::__capture_isunordered(__f1, __f2); } 590 591_GLIBCXX_END_NAMESPACE 592using std::isnan; 593using std::isinf; 594 595#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ 596#endif 597 598#ifndef _GLIBCXX_EXPORT_TEMPLATE 599# include <bits/cmath.tcc> 600#endif 601 602#endif 603