1// -*- C++ -*- C forwarding header. 2 3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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// 32// ISO C++ 14882: 26.5 C library 33// 34 35/** @file cmath 36 * This is a Standard C++ Library file. You should @c #include this file 37 * in your programs, rather than any of the "*.h" implementation files. 38 * 39 * This is the C++ version of the Standard C Library header @c math.h, 40 * and its contents are (mostly) the same as that header, but are all 41 * contained in the namespace @c std. 42 */ 43 44#ifndef _CPP_CMATH 45#define _CPP_CMATH 1 46 47#pragma GCC system_header 48 49#include <bits/c++config.h> 50#include <bits/cpp_type_traits.h> 51 52#include <math.h> 53 54// Get rid of those macros defined in <math.h> in lieu of real functions. 55#undef abs 56#undef div 57#undef acos 58#undef asin 59#undef atan 60#undef atan2 61#undef ceil 62#undef cos 63#undef cosh 64#undef exp 65#undef fabs 66#undef floor 67#undef fmod 68#undef frexp 69#undef ldexp 70#undef log 71#undef log10 72#undef modf 73#undef pow 74#undef sin 75#undef sinh 76#undef sqrt 77#undef tan 78#undef tanh 79 80// ...and in the darkness bind them... 81namespace __gnu_cxx 82{ 83 namespace __c99_binding 84 { 85#if defined(_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK) || \ 86 defined(_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC) 87 extern "C" float (acosf)(float); 88 extern "C" float (asinf)(float); 89 extern "C" float (atanf)(float); 90 extern "C" float (atan2f)(float, float); 91 extern "C" float (ceilf)(float); 92 extern "C" float (coshf)(float); 93 extern "C" float (expf)(float); 94 extern "C" float (floorf)(float); 95 extern "C" float (fmodf)(float, float); 96 extern "C" float (frexpf)(float, int*); 97 extern "C" float (ldexpf)(float, int); 98 extern "C" float (logf)(float); 99 extern "C" float (log10f)(float); 100 extern "C" float (modff)(float, float*); 101 extern "C" float (powf)(float, float); 102 extern "C" float (sinhf)(float); 103 extern "C" float (tanf)(float); 104 extern "C" float (tanhf)(float); 105#endif 106#if !defined(_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC) 107#if defined(_GLIBCPP_HAVE_ACOSF) 108 using ::acosf; 109#endif 110#if defined(_GLIBCPP_HAVE_ASINF) 111 using ::asinf; 112#endif 113#if defined(_GLIBCPP_HAVE_ATANF) 114 using ::atanf; 115#endif 116#if defined(_GLIBCPP_HAVE_ATAN2F) 117 using ::atan2f; 118#endif 119#if defined(_GLIBCPP_HAVE_CEILF) 120 using ::ceilf; 121#endif 122#if defined(_GLIBCPP_HAVE_COSHF) 123 using ::coshf; 124#endif 125#if defined(_GLIBCPP_HAVE_EXPF) 126 using ::expf; 127#endif 128#if defined(_GLIBCPP_HAVE_FLOORF) 129 using ::floorf; 130#endif 131#if defined(_GLIBCPP_HAVE_FMODF) 132 using ::fmodf; 133#endif 134#if defined(_GLIBCPP_HAVE_FREXPF) 135 using ::frexpf; 136#endif 137#if defined(_GLIBCPP_HAVE_LDEXPF) 138 using ::ldexpf; 139#endif 140#if defined(_GLIBCPP_HAVE_LOGF) 141 using ::logf; 142#endif 143#if defined(_GLIBCPP_HAVE_LOG10F) 144 using ::log10f; 145#endif 146#if defined(_GLIBCPP_HAVE_MODFF) 147 using ::modff; 148#endif 149#if defined(_GLIBCPP_HAVE_POWF) 150 using ::powf; 151#endif 152#if defined(_GLIBCPP_HAVE_SINHF) 153 using ::sinhf; 154#endif 155#if defined(_GLIBCPP_HAVE_TANF) 156 using ::tanf; 157#endif 158#if defined(_GLIBCPP_HAVE_TANHF) 159 using ::tanhf; 160#endif 161#endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */ 162 } 163} 164 165namespace std 166{ 167 // Forward declaration of a helper function. This really should be 168 // an `exported' forward declaration. 169 template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int); 170 171 inline double 172 abs(double __x) 173 { return __builtin_fabs(__x); } 174 175 inline float 176 abs(float __x) 177 { return __builtin_fabsf(__x); } 178 179 inline long double 180 abs(long double __x) 181 { return __builtin_fabsl(__x); } 182 183#if defined(_GLIBCPP_HAVE_ACOSF) 184 inline float 185 acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); } 186#else 187 inline float 188 acos(float __x) { return ::acos(static_cast<double>(__x)); } 189#endif 190 191 using ::acos; 192 193#if defined(_GLIBCPP_HAVE_ACOSL) 194 inline long double 195 acos(long double __x) { return ::acosl(__x); } 196#else 197 inline long double 198 acos(long double __x) { return ::acos(static_cast<double>(__x)); } 199#endif 200 201 template<typename _Tp> 202 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 203 acos(_Tp __x) 204 { 205 return ::acos(static_cast<double>(__x)); 206 } 207 208 using ::asin; 209 210#if defined(_GLIBCPP_HAVE_ASINF) 211 inline float 212 asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); } 213#else 214 inline float 215 asin(float __x) { return ::asin(static_cast<double>(__x)); } 216#endif 217 218#if defined(_GLIBCPP_HAVE_ASINL) 219 inline long double 220 asin(long double __x) { return ::asinl(__x); } 221#else 222 inline long double 223 asin(long double __x) { return ::asin(static_cast<double>(__x)); } 224#endif 225 226 template<typename _Tp> 227 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 228 asin(_Tp __x) 229 { return ::asin(static_cast<double>(__x)); } 230 231 using ::atan; 232 233#if defined(_GLIBCPP_HAVE_ATANF) 234 inline float 235 atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); } 236#else 237 inline float 238 atan(float __x) { return ::atan(static_cast<double>(__x)); } 239#endif 240 241#if defined(_GLIBCPP_HAVE_ATANL) 242 inline long double 243 atan(long double __x) { return ::atanl(__x); } 244#else 245 inline long double 246 atan(long double __x) { return ::atan(static_cast<double>(__x)); } 247#endif 248 249 template<typename _Tp> 250 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 251 atan(_Tp __x) 252 { return ::atan(static_cast<double>(__x)); } 253 254 using ::atan2; 255 256#if defined(_GLIBCPP_HAVE_ATAN2F) 257 inline float 258 atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); } 259#else 260 inline float 261 atan2(float __y, float __x) 262 { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); } 263#endif 264 265#if defined(_GLIBCPP_HAVE_ATAN2L) 266 inline long double 267 atan2(long double __y, long double __x) { return ::atan2l(__y, __x); } 268#else 269 inline long double 270 atan2(long double __y, long double __x) 271 { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); } 272#endif 273 274 template<typename _Tp, typename _Up> 275 inline typename __enable_if<double, __is_integer<_Tp>::_M_type 276 && __is_integer<_Up>::_M_type>::_M_type 277 atan2(_Tp __x, _Up __y) 278 { return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); } 279 280 using ::ceil; 281 282#if defined(_GLIBCPP_HAVE_CEILF) 283 inline float 284 ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); } 285#else 286 inline float 287 ceil(float __x) { return ::ceil(static_cast<double>(__x)); } 288#endif 289 290#if defined(_GLIBCPP_HAVE_CEILL) 291 inline long double 292 ceil(long double __x) { return ::ceill(__x); } 293#else 294 inline long double 295 ceil(long double __x) { return ::ceil(static_cast<double>(__x)); } 296#endif 297 298 template<typename _Tp> 299 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 300 ceil(_Tp __x) 301 { return ::ceil(static_cast<double>(__x)); } 302 303 using ::cos; 304 305 inline float 306 cos(float __x) 307 { return __builtin_cosf(__x); } 308 309 inline long double 310 cos(long double __x) 311 { return __builtin_cosl(__x); } 312 313 template<typename _Tp> 314 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 315 cos(_Tp __x) 316 { return __builtin_cos(__x); } 317 318 using ::cosh; 319 320#if defined(_GLIBCPP_HAVE_COSHF) 321 inline float 322 cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); } 323#else 324 inline float 325 cosh(float __x) { return ::cosh(static_cast<double>(__x)); } 326#endif 327 328#if defined(_GLIBCPP_HAVE_COSHL) 329 inline long double 330 cosh(long double __x) { return ::coshl(__x); } 331#else 332 inline long double 333 cosh(long double __x) { return ::cosh(static_cast<double>(__x)); } 334#endif 335 336 template<typename _Tp> 337 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 338 cosh(_Tp __x) 339 { return ::cosh(static_cast<double>(__x)); } 340 341 using ::exp; 342 343#if defined(_GLIBCPP_HAVE_EXPF) 344 inline float 345 exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); } 346#else 347 inline float 348 exp(float __x) { return ::exp(static_cast<double>(__x)); } 349#endif 350 351#if defined(_GLIBCPP_HAVE_EXPL) 352 inline long double 353 exp(long double __x) { return ::expl(__x); } 354#else 355 inline long double 356 exp(long double __x) { return ::exp(static_cast<double>(__x)); } 357#endif 358 359 template<typename _Tp> 360 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 361 exp(_Tp __x) 362 { return ::exp(static_cast<double>(__x)); } 363 364 using ::fabs; 365 366 inline float 367 fabs(float __x) 368 { return __builtin_fabsf(__x); } 369 370 inline long double 371 fabs(long double __x) 372 { return __builtin_fabsl(__x); } 373 374 template<typename _Tp> 375 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 376 fabs(_Tp __x) 377 { return __builtin_fabs(__x); } 378 379 using ::floor; 380 381#if defined(_GLIBCPP_HAVE_FLOORF) 382 inline float 383 floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); } 384#else 385 inline float 386 floor(float __x) { return ::floor(static_cast<double>(__x)); } 387#endif 388 389#if defined(_GLIBCPP_HAVE_FLOORL) 390 inline long double 391 floor(long double __x) { return ::floorl(__x); } 392#else 393 inline long double 394 floor(long double __x) { return ::floor(static_cast<double>(__x)); } 395#endif 396 397 template<typename _Tp> 398 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 399 floor(_Tp __x) 400 { return ::floor(static_cast<double>(__x)); } 401 402 using ::fmod; 403 404#if defined(_GLIBCPP_HAVE_FMODF) 405 inline float 406 fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); } 407#else 408 inline float 409 fmod(float __x, float __y) 410 { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); } 411#endif 412 413#if defined(_GLIBCPP_HAVE_FMODL) 414 inline long double 415 fmod(long double __x, long double __y) { return ::fmodl(__x, __y); } 416#else 417 inline long double 418 fmod(long double __x, long double __y) 419 { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); } 420#endif 421 422 using ::frexp; 423 424#if defined(_GLIBCPP_HAVE_FREXPF) 425 inline float 426 frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); } 427#else 428 inline float 429 frexp(float __x, int* __exp) { return ::frexp(__x, __exp); } 430#endif 431 432#if defined(_GLIBCPP_HAVE_FREXPL) 433 inline long double 434 frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); } 435#else 436 inline long double 437 frexp(long double __x, int* __exp) 438 { return ::frexp(static_cast<double>(__x), __exp); } 439#endif 440 441 template<typename _Tp> 442 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 443 frexp(_Tp __x, int* __exp) 444 { return ::frexp(static_cast<double>(__x), __exp); } 445 446 using ::ldexp; 447 448#if defined(_GLIBCPP_HAVE_LDEXPF) 449 inline float 450 ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); } 451#else 452 inline float 453 ldexp(float __x, int __exp) 454 { return ::ldexp(static_cast<double>(__x), __exp); } 455#endif 456 457#if defined(_GLIBCPP_HAVE_LDEXPL) 458 inline long double 459 ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); } 460#else 461 inline long double 462 ldexp(long double __x, int __exp) 463 { return ::ldexp(static_cast<double>(__x), __exp); } 464#endif 465 466 template<typename _Tp> 467 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 468 ldexp(_Tp __x, int __exp) 469 { return ::ldexp(static_cast<double>(__x), __exp); } 470 471 using ::log; 472 473#if defined(_GLIBCPP_HAVE_LOGF) 474 inline float 475 log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); } 476#else 477 inline float log(float __x) 478 { return ::log(static_cast<double>(__x)); } 479#endif 480 481#if defined(_GLIBCPP_HAVE_LOGL) 482 inline long double 483 log(long double __x) { return ::logl(__x); } 484#else 485 inline long double 486 log(long double __x) { return ::log(static_cast<double>(__x)); } 487#endif 488 489 template<typename _Tp> 490 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 491 log(_Tp __x) 492 { return ::log(static_cast<double>(__x)); } 493 494 using ::log10; 495 496#if defined(_GLIBCPP_HAVE_LOG10F) 497 inline float 498 log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); } 499#else 500 inline float 501 log10(float __x) { return ::log10(static_cast<double>(__x)); } 502#endif 503 504#if defined(_GLIBCPP_HAVE_LOG10L) 505 inline long double 506 log10(long double __x) { return ::log10l(__x); } 507#else 508 inline long double 509 log10(long double __x) { return ::log10(static_cast<double>(__x)); } 510#endif 511 512 template<typename _Tp> 513 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 514 log10(_Tp __x) 515 { return ::log10(static_cast<double>(__x)); } 516 517 using ::modf; 518 519#if defined(_GLIBCPP_HAVE_MODFF) 520 inline float 521 modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); } 522#else 523 inline float 524 modf(float __x, float* __iptr) 525 { 526 double __tmp; 527 double __res = ::modf(static_cast<double>(__x), &__tmp); 528 *__iptr = static_cast<float>(__tmp); 529 return __res; 530 } 531#endif 532 533#if defined(_GLIBCPP_HAVE_MODFL) 534 inline long double 535 modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); } 536#else 537 inline long double 538 modf(long double __x, long double* __iptr) 539 { 540 double __tmp; 541 double __res = ::modf(static_cast<double>(__x), &__tmp); 542 * __iptr = static_cast<long double>(__tmp); 543 return __res; 544 } 545#endif 546 547 template<typename _Tp> 548 inline _Tp 549 __pow_helper(_Tp __x, int __n) 550 { 551 return __n < 0 552 ? _Tp(1)/__cmath_power(__x, -__n) 553 : __cmath_power(__x, __n); 554 } 555 556 using ::pow; 557 558#if defined(_GLIBCPP_HAVE_POWF) 559 inline float 560 pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); } 561#else 562 inline float 563 pow(float __x, float __y) 564 { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); } 565#endif 566 567#if defined(_GLIBCPP_HAVE_POWL) 568 inline long double 569 pow(long double __x, long double __y) { return ::powl(__x, __y); } 570#else 571 inline long double 572 pow(long double __x, long double __y) 573 { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); } 574#endif 575 576 inline double 577 pow(double __x, int __i) 578 { return __pow_helper(__x, __i); } 579 580 inline float 581 pow(float __x, int __n) 582 { return __pow_helper(__x, __n); } 583 584 inline long double 585 pow(long double __x, int __n) 586 { return __pow_helper(__x, __n); } 587 588 using ::sin; 589 590 inline float 591 sin(float __x) 592 { return __builtin_sinf(__x); } 593 594 inline long double 595 sin(long double __x) 596 { return __builtin_sinl(__x); } 597 598 template<typename _Tp> 599 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 600 sin(_Tp __x) 601 { return __builtin_sin(__x); } 602 603 using ::sinh; 604 605#if defined(_GLIBCPP_HAVE_SINHF) 606 inline float 607 sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); } 608#else 609 inline float 610 sinh(float __x) { return ::sinh(static_cast<double>(__x)); } 611#endif 612 613#if defined(_GLIBCPP_HAVE_SINHL) 614 inline long double 615 sinh(long double __x) { return ::sinhl(__x); } 616#else 617 inline long double 618 sinh(long double __x) { return ::sinh(static_cast<double>(__x)); } 619#endif 620 621 template<typename _Tp> 622 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 623 sinh(_Tp __x) 624 { return ::sinh(static_cast<_Tp>(__x)); } 625 626 using ::sqrt; 627 628 inline float 629 sqrt(float __x) 630 { return __builtin_sqrtf(__x); } 631 632 inline long double 633 sqrt(long double __x) 634 { return __builtin_sqrtl(__x); } 635 636 template<typename _Tp> 637 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 638 sqrt(_Tp __x) 639 { return __builtin_sqrt(__x); } 640 641 using ::tan; 642 643#if defined(_GLIBCPP_HAVE_TANF) 644 inline float 645 tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); } 646#else 647 inline float 648 tan(float __x) { return ::tan(static_cast<double>(__x)); } 649#endif 650 651#if defined(_GLIBCPP_HAVE_TANL) 652 inline long double 653 tan(long double __x) { return ::tanl(__x); } 654#else 655 inline long double 656 tan(long double __x) { return ::tan(static_cast<double>(__x)); } 657#endif 658 659 template<typename _Tp> 660 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 661 tan(_Tp __x) 662 { return ::tan(static_cast<double>(__x)); } 663 664 using ::tanh; 665 666#if defined(_GLIBCPP_HAVE_TANHF) 667 inline float 668 tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); } 669#else 670 inline float 671 tanh(float __x) { return ::tanh(static_cast<double>(__x)); } 672#endif 673 674#if defined(_GLIBCPP_HAVE_TANHL) 675 inline long double 676 tanh(long double __x) { return ::tanhl(__x); } 677#else 678 inline long double 679 tanh(long double __x) { return ::tanh(static_cast<double>(__x)); } 680#endif 681 682 template<typename _Tp> 683 inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type 684 tanh(_Tp __x) 685 { return ::tanh(static_cast<double>(__x)); } 686} 687 688 689#if defined(_GLIBCPP_USE_C99) 690#if !defined(_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC) 691// These are possible macros imported from C99-land. For strict 692// conformance, remove possible C99-injected names from the global 693// namespace, and sequester them in the __gnu_cxx extension namespace. 694namespace __gnu_cxx 695{ 696 template<typename _Tp> 697 int 698 __capture_fpclassify(_Tp __f) { return fpclassify(__f); } 699 700 template<typename _Tp> 701 int 702 __capture_isfinite(_Tp __f) { return isfinite(__f); } 703 704 template<typename _Tp> 705 int 706 __capture_isinf(_Tp __f) { return isinf(__f); } 707 708 template<typename _Tp> 709 int 710 __capture_isnan(_Tp __f) { return isnan(__f); } 711 712 template<typename _Tp> 713 int 714 __capture_isnormal(_Tp __f) { return isnormal(__f); } 715 716 template<typename _Tp> 717 int 718 __capture_signbit(_Tp __f) { return signbit(__f); } 719 720 template<typename _Tp> 721 int 722 __capture_isgreater(_Tp __f1, _Tp __f2) 723 { return isgreater(__f1, __f2); } 724 725 template<typename _Tp> 726 int 727 __capture_isgreaterequal(_Tp __f1, _Tp __f2) 728 { return isgreaterequal(__f1, __f2); } 729 730 template<typename _Tp> 731 int 732 __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); } 733 734 template<typename _Tp> 735 int 736 __capture_islessequal(_Tp __f1, _Tp __f2) 737 { return islessequal(__f1, __f2); } 738 739 template<typename _Tp> 740 int 741 __capture_islessgreater(_Tp __f1, _Tp __f2) 742 { return islessgreater(__f1, __f2); } 743 744 template<typename _Tp> 745 int 746 __capture_isunordered(_Tp __f1, _Tp __f2) 747 { return isunordered(__f1, __f2); } 748} 749 750#undef fpclassify 751#undef isfinite 752#undef isinf 753#undef isnan 754#undef isnormal 755#undef signbit 756#undef isgreater 757#undef isgreaterequal 758#undef isless 759#undef islessequal 760#undef islessgreater 761#undef isunordered 762 763namespace __gnu_cxx 764{ 765 template<typename _Tp> 766 int 767 fpclassify(_Tp __f) { return __capture_fpclassify(__f); } 768 769 template<typename _Tp> 770 int 771 isfinite(_Tp __f) { return __capture_isfinite(__f); } 772 773 template<typename _Tp> 774 int 775 isinf(_Tp __f) { return __capture_isinf(__f); } 776 777 template<typename _Tp> 778 int 779 isnan(_Tp __f) { return __capture_isnan(__f); } 780 781 template<typename _Tp> 782 int 783 isnormal(_Tp __f) { return __capture_isnormal(__f); } 784 785 template<typename _Tp> 786 int 787 signbit(_Tp __f) { return __capture_signbit(__f); } 788 789 template<typename _Tp> 790 int 791 isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); } 792 793 template<typename _Tp> 794 int 795 isgreaterequal(_Tp __f1, _Tp __f2) 796 { return __capture_isgreaterequal(__f1, __f2); } 797 798 template<typename _Tp> 799 int 800 isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); } 801 802 template<typename _Tp> 803 int 804 islessequal(_Tp __f1, _Tp __f2) 805 { return __capture_islessequal(__f1, __f2); } 806 807 template<typename _Tp> 808 int 809 islessgreater(_Tp __f1, _Tp __f2) 810 { return __capture_islessgreater(__f1, __f2); } 811 812 template<typename _Tp> 813 int 814 isunordered(_Tp __f1, _Tp __f2) 815 { return __capture_isunordered(__f1, __f2); } 816} 817 818namespace std 819{ 820 using __gnu_cxx::fpclassify; 821 using __gnu_cxx::isfinite; 822 using __gnu_cxx::isinf; 823 using __gnu_cxx::isnan; 824 using __gnu_cxx::isnormal; 825 using __gnu_cxx::signbit; 826 using __gnu_cxx::isgreater; 827 using __gnu_cxx::isgreaterequal; 828 using __gnu_cxx::isless; 829 using __gnu_cxx::islessequal; 830 using __gnu_cxx::islessgreater; 831 using __gnu_cxx::isunordered; 832} 833#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */ 834#endif 835 836#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT 837# define export 838# include <bits/cmath.tcc> 839#endif 840 841#endif 842