1 // -*- C++ -*- C forwarding header. 2 3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4 // 2006, 2007, 2008, 2009, 2010, 2011 5 // Free Software Foundation, Inc. 6 // 7 // This file is part of the GNU ISO C++ Library. This library is free 8 // software; you can redistribute it and/or modify it under the 9 // terms of the GNU General Public License as published by the 10 // Free Software Foundation; either version 3, or (at your option) 11 // any later version. 12 13 // This library is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // Under Section 7 of GPL version 3, you are granted additional 19 // permissions described in the GCC Runtime Library Exception, version 20 // 3.1, as published by the Free Software Foundation. 21 22 // You should have received a copy of the GNU General Public License and 23 // a copy of the GCC Runtime Library Exception along with this program; 24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 25 // <http://www.gnu.org/licenses/>. 26 27 /** @file include/cmath 28 * This is a Standard C++ Library file. You should @c \#include this file 29 * in your programs, rather than any of the @a *.h implementation files. 30 * 31 * This is the C++ version of the Standard C Library header @c math.h, 32 * and its contents are (mostly) the same as that header, but are all 33 * contained in the namespace @c std (except for names which are defined 34 * as macros in C). 35 */ 36 37 // 38 // ISO C++ 14882: 26.5 C library 39 // 40 41 #pragma GCC system_header 42 43 #include <bits/c++config.h> 44 #include <bits/cpp_type_traits.h> 45 #include <ext/type_traits.h> 46 #include <math.h> 47 48 #ifndef _GLIBCXX_CMATH 49 #define _GLIBCXX_CMATH 1 50 51 // Get rid of those macros defined in <math.h> in lieu of real functions. 52 #undef abs 53 #undef div 54 #undef acos 55 #undef asin 56 #undef atan 57 #undef atan2 58 #undef ceil 59 #undef cos 60 #undef cosh 61 #undef exp 62 #undef fabs 63 #undef floor 64 #undef fmod 65 #undef frexp 66 #undef ldexp 67 #undef log 68 #undef log10 69 #undef modf 70 #undef pow 71 #undef sin 72 #undef sinh 73 #undef sqrt 74 #undef tan 75 #undef tanh 76 77 namespace std _GLIBCXX_VISIBILITY(default) 78 { 79 _GLIBCXX_BEGIN_NAMESPACE_VERSION 80 81 #if !defined(__CORRECT_ISO_CPP_MATH_H_PROTO1) \ 82 && !defined(__CORRECT_ISO_CPP_MATH_H_PROTO2) 83 inline _GLIBCXX_CONSTEXPR double 84 abs(double __x) 85 { return __builtin_fabs(__x); } 86 #endif 87 88 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 89 inline _GLIBCXX_CONSTEXPR float 90 abs(float __x) 91 { return __builtin_fabsf(__x); } 92 93 inline _GLIBCXX_CONSTEXPR long double 94 abs(long double __x) 95 { return __builtin_fabsl(__x); } 96 #endif 97 98 template<typename _Tp> 99 inline _GLIBCXX_CONSTEXPR 100 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 101 double>::__type 102 abs(_Tp __x) 103 { return __builtin_fabs(__x); } 104 105 using ::acos; 106 107 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 108 inline _GLIBCXX_CONSTEXPR float 109 acos(float __x) 110 { return __builtin_acosf(__x); } 111 112 inline _GLIBCXX_CONSTEXPR long double 113 acos(long double __x) 114 { return __builtin_acosl(__x); } 115 #endif 116 117 template<typename _Tp> 118 inline _GLIBCXX_CONSTEXPR 119 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 120 double>::__type 121 acos(_Tp __x) 122 { return __builtin_acos(__x); } 123 124 using ::asin; 125 126 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 127 inline _GLIBCXX_CONSTEXPR float 128 asin(float __x) 129 { return __builtin_asinf(__x); } 130 131 inline _GLIBCXX_CONSTEXPR long double 132 asin(long double __x) 133 { return __builtin_asinl(__x); } 134 #endif 135 136 template<typename _Tp> 137 inline _GLIBCXX_CONSTEXPR 138 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 139 double>::__type 140 asin(_Tp __x) 141 { return __builtin_asin(__x); } 142 143 using ::atan; 144 145 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 146 inline _GLIBCXX_CONSTEXPR float 147 atan(float __x) 148 { return __builtin_atanf(__x); } 149 150 inline _GLIBCXX_CONSTEXPR long double 151 atan(long double __x) 152 { return __builtin_atanl(__x); } 153 #endif 154 155 template<typename _Tp> 156 inline _GLIBCXX_CONSTEXPR 157 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 158 double>::__type 159 atan(_Tp __x) 160 { return __builtin_atan(__x); } 161 162 using ::atan2; 163 164 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 165 inline _GLIBCXX_CONSTEXPR float 166 atan2(float __y, float __x) 167 { return __builtin_atan2f(__y, __x); } 168 169 inline _GLIBCXX_CONSTEXPR long double 170 atan2(long double __y, long double __x) 171 { return __builtin_atan2l(__y, __x); } 172 #endif 173 174 template<typename _Tp, typename _Up> 175 inline _GLIBCXX_CONSTEXPR 176 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 177 atan2(_Tp __y, _Up __x) 178 { 179 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 180 return atan2(__type(__y), __type(__x)); 181 } 182 183 using ::ceil; 184 185 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 186 inline _GLIBCXX_CONSTEXPR float 187 ceil(float __x) 188 { return __builtin_ceilf(__x); } 189 190 inline _GLIBCXX_CONSTEXPR long double 191 ceil(long double __x) 192 { return __builtin_ceill(__x); } 193 #endif 194 195 template<typename _Tp> 196 inline _GLIBCXX_CONSTEXPR 197 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 198 double>::__type 199 ceil(_Tp __x) 200 { return __builtin_ceil(__x); } 201 202 using ::cos; 203 204 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 205 inline _GLIBCXX_CONSTEXPR float 206 cos(float __x) 207 { return __builtin_cosf(__x); } 208 209 inline _GLIBCXX_CONSTEXPR long double 210 cos(long double __x) 211 { return __builtin_cosl(__x); } 212 #endif 213 214 template<typename _Tp> 215 inline _GLIBCXX_CONSTEXPR 216 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 217 double>::__type 218 cos(_Tp __x) 219 { return __builtin_cos(__x); } 220 221 using ::cosh; 222 223 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 224 inline _GLIBCXX_CONSTEXPR float 225 cosh(float __x) 226 { return __builtin_coshf(__x); } 227 228 inline _GLIBCXX_CONSTEXPR long double 229 cosh(long double __x) 230 { return __builtin_coshl(__x); } 231 #endif 232 233 template<typename _Tp> 234 inline _GLIBCXX_CONSTEXPR 235 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 236 double>::__type 237 cosh(_Tp __x) 238 { return __builtin_cosh(__x); } 239 240 using ::exp; 241 242 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 243 inline _GLIBCXX_CONSTEXPR float 244 exp(float __x) 245 { return __builtin_expf(__x); } 246 247 inline _GLIBCXX_CONSTEXPR long double 248 exp(long double __x) 249 { return __builtin_expl(__x); } 250 #endif 251 252 template<typename _Tp> 253 inline _GLIBCXX_CONSTEXPR 254 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 255 double>::__type 256 exp(_Tp __x) 257 { return __builtin_exp(__x); } 258 259 using ::fabs; 260 261 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 262 inline _GLIBCXX_CONSTEXPR float 263 fabs(float __x) 264 { return __builtin_fabsf(__x); } 265 266 inline _GLIBCXX_CONSTEXPR long double 267 fabs(long double __x) 268 { return __builtin_fabsl(__x); } 269 #endif 270 271 template<typename _Tp> 272 inline _GLIBCXX_CONSTEXPR 273 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 274 double>::__type 275 fabs(_Tp __x) 276 { return __builtin_fabs(__x); } 277 278 using ::floor; 279 280 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 281 inline _GLIBCXX_CONSTEXPR float 282 floor(float __x) 283 { return __builtin_floorf(__x); } 284 285 inline _GLIBCXX_CONSTEXPR long double 286 floor(long double __x) 287 { return __builtin_floorl(__x); } 288 #endif 289 290 template<typename _Tp> 291 inline _GLIBCXX_CONSTEXPR 292 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 293 double>::__type 294 floor(_Tp __x) 295 { return __builtin_floor(__x); } 296 297 using ::fmod; 298 299 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 300 inline _GLIBCXX_CONSTEXPR float 301 fmod(float __x, float __y) 302 { return __builtin_fmodf(__x, __y); } 303 304 inline _GLIBCXX_CONSTEXPR long double 305 fmod(long double __x, long double __y) 306 { return __builtin_fmodl(__x, __y); } 307 #endif 308 309 template<typename _Tp, typename _Up> 310 inline _GLIBCXX_CONSTEXPR 311 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 312 fmod(_Tp __x, _Up __y) 313 { 314 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 315 return fmod(__type(__x), __type(__y)); 316 } 317 318 using ::frexp; 319 320 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 321 inline float 322 frexp(float __x, int* __exp) 323 { return __builtin_frexpf(__x, __exp); } 324 325 inline long double 326 frexp(long double __x, int* __exp) 327 { return __builtin_frexpl(__x, __exp); } 328 #endif 329 330 template<typename _Tp> 331 inline _GLIBCXX_CONSTEXPR 332 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 333 double>::__type 334 frexp(_Tp __x, int* __exp) 335 { return __builtin_frexp(__x, __exp); } 336 337 using ::ldexp; 338 339 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 340 inline _GLIBCXX_CONSTEXPR float 341 ldexp(float __x, int __exp) 342 { return __builtin_ldexpf(__x, __exp); } 343 344 inline _GLIBCXX_CONSTEXPR long double 345 ldexp(long double __x, int __exp) 346 { return __builtin_ldexpl(__x, __exp); } 347 #endif 348 349 template<typename _Tp> 350 inline _GLIBCXX_CONSTEXPR 351 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 352 double>::__type 353 ldexp(_Tp __x, int __exp) 354 { return __builtin_ldexp(__x, __exp); } 355 356 using ::log; 357 358 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 359 inline _GLIBCXX_CONSTEXPR float 360 log(float __x) 361 { return __builtin_logf(__x); } 362 363 inline _GLIBCXX_CONSTEXPR long double 364 log(long double __x) 365 { return __builtin_logl(__x); } 366 #endif 367 368 template<typename _Tp> 369 inline _GLIBCXX_CONSTEXPR 370 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 371 double>::__type 372 log(_Tp __x) 373 { return __builtin_log(__x); } 374 375 using ::log10; 376 377 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 378 inline _GLIBCXX_CONSTEXPR float 379 log10(float __x) 380 { return __builtin_log10f(__x); } 381 382 inline _GLIBCXX_CONSTEXPR long double 383 log10(long double __x) 384 { return __builtin_log10l(__x); } 385 #endif 386 387 template<typename _Tp> 388 inline _GLIBCXX_CONSTEXPR 389 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 390 double>::__type 391 log10(_Tp __x) 392 { return __builtin_log10(__x); } 393 394 using ::modf; 395 396 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 397 inline float 398 modf(float __x, float* __iptr) 399 { return __builtin_modff(__x, __iptr); } 400 401 inline long double 402 modf(long double __x, long double* __iptr) 403 { return __builtin_modfl(__x, __iptr); } 404 #endif 405 406 using ::pow; 407 408 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 409 inline _GLIBCXX_CONSTEXPR float 410 pow(float __x, float __y) 411 { return __builtin_powf(__x, __y); } 412 413 inline _GLIBCXX_CONSTEXPR long double 414 pow(long double __x, long double __y) 415 { return __builtin_powl(__x, __y); } 416 417 #ifndef __GXX_EXPERIMENTAL_CXX0X__ 418 // _GLIBCXX_RESOLVE_LIB_DEFECTS 419 // DR 550. What should the return type of pow(float,int) be? 420 inline double 421 pow(double __x, int __i) 422 { return __builtin_powi(__x, __i); } 423 424 inline float 425 pow(float __x, int __n) 426 { return __builtin_powif(__x, __n); } 427 428 inline long double 429 pow(long double __x, int __n) 430 { return __builtin_powil(__x, __n); } 431 #endif 432 #endif 433 434 template<typename _Tp, typename _Up> 435 inline _GLIBCXX_CONSTEXPR 436 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 437 pow(_Tp __x, _Up __y) 438 { 439 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 440 return pow(__type(__x), __type(__y)); 441 } 442 443 using ::sin; 444 445 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 446 inline _GLIBCXX_CONSTEXPR float 447 sin(float __x) 448 { return __builtin_sinf(__x); } 449 450 inline _GLIBCXX_CONSTEXPR long double 451 sin(long double __x) 452 { return __builtin_sinl(__x); } 453 #endif 454 455 template<typename _Tp> 456 inline _GLIBCXX_CONSTEXPR 457 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 458 double>::__type 459 sin(_Tp __x) 460 { return __builtin_sin(__x); } 461 462 using ::sinh; 463 464 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 465 inline _GLIBCXX_CONSTEXPR float 466 sinh(float __x) 467 { return __builtin_sinhf(__x); } 468 469 inline _GLIBCXX_CONSTEXPR long double 470 sinh(long double __x) 471 { return __builtin_sinhl(__x); } 472 #endif 473 474 template<typename _Tp> 475 inline _GLIBCXX_CONSTEXPR 476 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 477 double>::__type 478 sinh(_Tp __x) 479 { return __builtin_sinh(__x); } 480 481 using ::sqrt; 482 483 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 484 inline _GLIBCXX_CONSTEXPR float 485 sqrt(float __x) 486 { return __builtin_sqrtf(__x); } 487 488 inline _GLIBCXX_CONSTEXPR long double 489 sqrt(long double __x) 490 { return __builtin_sqrtl(__x); } 491 #endif 492 493 template<typename _Tp> 494 inline _GLIBCXX_CONSTEXPR 495 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 496 double>::__type 497 sqrt(_Tp __x) 498 { return __builtin_sqrt(__x); } 499 500 using ::tan; 501 502 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 503 inline _GLIBCXX_CONSTEXPR float 504 tan(float __x) 505 { return __builtin_tanf(__x); } 506 507 inline _GLIBCXX_CONSTEXPR long double 508 tan(long double __x) 509 { return __builtin_tanl(__x); } 510 #endif 511 512 template<typename _Tp> 513 inline _GLIBCXX_CONSTEXPR 514 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 515 double>::__type 516 tan(_Tp __x) 517 { return __builtin_tan(__x); } 518 519 using ::tanh; 520 521 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO1 522 inline _GLIBCXX_CONSTEXPR float 523 tanh(float __x) 524 { return __builtin_tanhf(__x); } 525 526 inline _GLIBCXX_CONSTEXPR long double 527 tanh(long double __x) 528 { return __builtin_tanhl(__x); } 529 #endif 530 531 template<typename _Tp> 532 inline _GLIBCXX_CONSTEXPR 533 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 534 double>::__type 535 tanh(_Tp __x) 536 { return __builtin_tanh(__x); } 537 538 _GLIBCXX_END_NAMESPACE_VERSION 539 } // namespace 540 541 #if _GLIBCXX_USE_C99_MATH 542 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC 543 544 // These are possible macros imported from C99-land. 545 #undef fpclassify 546 #undef isfinite 547 #undef isinf 548 #undef isnan 549 #undef isnormal 550 #undef signbit 551 #undef isgreater 552 #undef isgreaterequal 553 #undef isless 554 #undef islessequal 555 #undef islessgreater 556 #undef isunordered 557 558 namespace std _GLIBCXX_VISIBILITY(default) 559 { 560 _GLIBCXX_BEGIN_NAMESPACE_VERSION 561 562 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 563 constexpr int 564 fpclassify(float __x) 565 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 566 FP_SUBNORMAL, FP_ZERO, __x); } 567 568 constexpr int 569 fpclassify(double __x) 570 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 571 FP_SUBNORMAL, FP_ZERO, __x); } 572 573 constexpr int 574 fpclassify(long double __x) 575 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 576 FP_SUBNORMAL, FP_ZERO, __x); } 577 578 template<typename _Tp> 579 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 580 int>::__type 581 fpclassify(_Tp __x) 582 { return __x != 0 ? FP_NORMAL : FP_ZERO; } 583 584 constexpr bool 585 isfinite(float __x) 586 { return __builtin_isfinite(__x); } 587 588 constexpr bool 589 isfinite(double __x) 590 { return __builtin_isfinite(__x); } 591 592 constexpr bool 593 isfinite(long double __x) 594 { return __builtin_isfinite(__x); } 595 596 template<typename _Tp> 597 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 598 bool>::__type 599 isfinite(_Tp __x) 600 { return true; } 601 602 constexpr bool 603 isinf(float __x) 604 { return __builtin_isinf(__x); } 605 606 constexpr bool 607 isinf(double __x) 608 { return __builtin_isinf(__x); } 609 610 constexpr bool 611 isinf(long double __x) 612 { return __builtin_isinf(__x); } 613 614 template<typename _Tp> 615 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 616 bool>::__type 617 isinf(_Tp __x) 618 { return false; } 619 620 constexpr bool 621 isnan(float __x) 622 { return __builtin_isnan(__x); } 623 624 constexpr bool 625 isnan(double __x) 626 { return __builtin_isnan(__x); } 627 628 constexpr bool 629 isnan(long double __x) 630 { return __builtin_isnan(__x); } 631 632 template<typename _Tp> 633 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 634 bool>::__type 635 isnan(_Tp __x) 636 { return false; } 637 638 constexpr bool 639 isnormal(float __x) 640 { return __builtin_isnormal(__x); } 641 642 constexpr bool 643 isnormal(double __x) 644 { return __builtin_isnormal(__x); } 645 646 constexpr bool 647 isnormal(long double __x) 648 { return __builtin_isnormal(__x); } 649 650 template<typename _Tp> 651 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 652 bool>::__type 653 isnormal(_Tp __x) 654 { return __x != 0 ? true : false; } 655 656 constexpr bool 657 signbit(float __x) 658 { return __builtin_signbit(__x); } 659 660 constexpr bool 661 signbit(double __x) 662 { return __builtin_signbit(__x); } 663 664 constexpr bool 665 signbit(long double __x) 666 { return __builtin_signbit(__x); } 667 668 template<typename _Tp> 669 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 670 bool>::__type 671 signbit(_Tp __x) 672 { return __x < 0 ? true : false; } 673 674 constexpr bool 675 isgreater(float __x, float __y) 676 { return __builtin_isgreater(__x, __y); } 677 678 constexpr bool 679 isgreater(double __x, double __y) 680 { return __builtin_isgreater(__x, __y); } 681 682 constexpr bool 683 isgreater(long double __x, long double __y) 684 { return __builtin_isgreater(__x, __y); } 685 686 template<typename _Tp, typename _Up> 687 constexpr typename 688 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 689 && __is_arithmetic<_Up>::__value), bool>::__type 690 isgreater(_Tp __x, _Up __y) 691 { 692 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 693 return __builtin_isgreater(__type(__x), __type(__y)); 694 } 695 696 constexpr bool 697 isgreaterequal(float __x, float __y) 698 { return __builtin_isgreaterequal(__x, __y); } 699 700 constexpr bool 701 isgreaterequal(double __x, double __y) 702 { return __builtin_isgreaterequal(__x, __y); } 703 704 constexpr bool 705 isgreaterequal(long double __x, long double __y) 706 { return __builtin_isgreaterequal(__x, __y); } 707 708 template<typename _Tp, typename _Up> 709 constexpr typename 710 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 711 && __is_arithmetic<_Up>::__value), bool>::__type 712 isgreaterequal(_Tp __x, _Up __y) 713 { 714 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 715 return __builtin_isgreaterequal(__type(__x), __type(__y)); 716 } 717 718 constexpr bool 719 isless(float __x, float __y) 720 { return __builtin_isless(__x, __y); } 721 722 constexpr bool 723 isless(double __x, double __y) 724 { return __builtin_isless(__x, __y); } 725 726 constexpr bool 727 isless(long double __x, long double __y) 728 { return __builtin_isless(__x, __y); } 729 730 template<typename _Tp, typename _Up> 731 constexpr typename 732 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 733 && __is_arithmetic<_Up>::__value), bool>::__type 734 isless(_Tp __x, _Up __y) 735 { 736 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 737 return __builtin_isless(__type(__x), __type(__y)); 738 } 739 740 constexpr bool 741 islessequal(float __x, float __y) 742 { return __builtin_islessequal(__x, __y); } 743 744 constexpr bool 745 islessequal(double __x, double __y) 746 { return __builtin_islessequal(__x, __y); } 747 748 constexpr bool 749 islessequal(long double __x, long double __y) 750 { return __builtin_islessequal(__x, __y); } 751 752 template<typename _Tp, typename _Up> 753 constexpr typename 754 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 755 && __is_arithmetic<_Up>::__value), bool>::__type 756 islessequal(_Tp __x, _Up __y) 757 { 758 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 759 return __builtin_islessequal(__type(__x), __type(__y)); 760 } 761 762 constexpr bool 763 islessgreater(float __x, float __y) 764 { return __builtin_islessgreater(__x, __y); } 765 766 constexpr bool 767 islessgreater(double __x, double __y) 768 { return __builtin_islessgreater(__x, __y); } 769 770 constexpr bool 771 islessgreater(long double __x, long double __y) 772 { return __builtin_islessgreater(__x, __y); } 773 774 template<typename _Tp, typename _Up> 775 constexpr typename 776 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 777 && __is_arithmetic<_Up>::__value), bool>::__type 778 islessgreater(_Tp __x, _Up __y) 779 { 780 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 781 return __builtin_islessgreater(__type(__x), __type(__y)); 782 } 783 784 constexpr bool 785 isunordered(float __x, float __y) 786 { return __builtin_isunordered(__x, __y); } 787 788 constexpr bool 789 isunordered(double __x, double __y) 790 { return __builtin_isunordered(__x, __y); } 791 792 constexpr bool 793 isunordered(long double __x, long double __y) 794 { return __builtin_isunordered(__x, __y); } 795 796 template<typename _Tp, typename _Up> 797 constexpr typename 798 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 799 && __is_arithmetic<_Up>::__value), bool>::__type 800 isunordered(_Tp __x, _Up __y) 801 { 802 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 803 return __builtin_isunordered(__type(__x), __type(__y)); 804 } 805 806 #else 807 808 template<typename _Tp> 809 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 810 int>::__type 811 fpclassify(_Tp __f) 812 { 813 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 814 return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 815 FP_SUBNORMAL, FP_ZERO, __type(__f)); 816 } 817 818 template<typename _Tp> 819 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 820 int>::__type 821 isfinite(_Tp __f) 822 { 823 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 824 return __builtin_isfinite(__type(__f)); 825 } 826 827 template<typename _Tp> 828 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 829 int>::__type 830 isinf(_Tp __f) 831 { 832 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 833 return __builtin_isinf(__type(__f)); 834 } 835 836 template<typename _Tp> 837 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 838 int>::__type 839 isnan(_Tp __f) 840 { 841 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 842 return __builtin_isnan(__type(__f)); 843 } 844 845 template<typename _Tp> 846 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 847 int>::__type 848 isnormal(_Tp __f) 849 { 850 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 851 return __builtin_isnormal(__type(__f)); 852 } 853 854 template<typename _Tp> 855 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 856 int>::__type 857 signbit(_Tp __f) 858 { 859 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 860 return __builtin_signbit(__type(__f)); 861 } 862 863 template<typename _Tp> 864 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 865 int>::__type 866 isgreater(_Tp __f1, _Tp __f2) 867 { 868 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 869 return __builtin_isgreater(__type(__f1), __type(__f2)); 870 } 871 872 template<typename _Tp> 873 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 874 int>::__type 875 isgreaterequal(_Tp __f1, _Tp __f2) 876 { 877 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 878 return __builtin_isgreaterequal(__type(__f1), __type(__f2)); 879 } 880 881 template<typename _Tp> 882 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 883 int>::__type 884 isless(_Tp __f1, _Tp __f2) 885 { 886 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 887 return __builtin_isless(__type(__f1), __type(__f2)); 888 } 889 890 template<typename _Tp> 891 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 892 int>::__type 893 islessequal(_Tp __f1, _Tp __f2) 894 { 895 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 896 return __builtin_islessequal(__type(__f1), __type(__f2)); 897 } 898 899 template<typename _Tp> 900 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 901 int>::__type 902 islessgreater(_Tp __f1, _Tp __f2) 903 { 904 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 905 return __builtin_islessgreater(__type(__f1), __type(__f2)); 906 } 907 908 template<typename _Tp> 909 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 910 int>::__type 911 isunordered(_Tp __f1, _Tp __f2) 912 { 913 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 914 return __builtin_isunordered(__type(__f1), __type(__f2)); 915 } 916 917 #endif 918 919 _GLIBCXX_END_NAMESPACE_VERSION 920 } // namespace 921 922 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ 923 #endif 924 925 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 926 927 #ifdef _GLIBCXX_USE_C99_MATH_TR1 928 929 #undef acosh 930 #undef acoshf 931 #undef acoshl 932 #undef asinh 933 #undef asinhf 934 #undef asinhl 935 #undef atanh 936 #undef atanhf 937 #undef atanhl 938 #undef cbrt 939 #undef cbrtf 940 #undef cbrtl 941 #undef copysign 942 #undef copysignf 943 #undef copysignl 944 #undef erf 945 #undef erff 946 #undef erfl 947 #undef erfc 948 #undef erfcf 949 #undef erfcl 950 #undef exp2 951 #undef exp2f 952 #undef exp2l 953 #undef expm1 954 #undef expm1f 955 #undef expm1l 956 #undef fdim 957 #undef fdimf 958 #undef fdiml 959 #undef fma 960 #undef fmaf 961 #undef fmal 962 #undef fmax 963 #undef fmaxf 964 #undef fmaxl 965 #undef fmin 966 #undef fminf 967 #undef fminl 968 #undef hypot 969 #undef hypotf 970 #undef hypotl 971 #undef ilogb 972 #undef ilogbf 973 #undef ilogbl 974 #undef lgamma 975 #undef lgammaf 976 #undef lgammal 977 #undef llrint 978 #undef llrintf 979 #undef llrintl 980 #undef llround 981 #undef llroundf 982 #undef llroundl 983 #undef log1p 984 #undef log1pf 985 #undef log1pl 986 #undef log2 987 #undef log2f 988 #undef log2l 989 #undef logb 990 #undef logbf 991 #undef logbl 992 #undef lrint 993 #undef lrintf 994 #undef lrintl 995 #undef lround 996 #undef lroundf 997 #undef lroundl 998 #undef nan 999 #undef nanf 1000 #undef nanl 1001 #undef nearbyint 1002 #undef nearbyintf 1003 #undef nearbyintl 1004 #undef nextafter 1005 #undef nextafterf 1006 #undef nextafterl 1007 #undef nexttoward 1008 #undef nexttowardf 1009 #undef nexttowardl 1010 #undef remainder 1011 #undef remainderf 1012 #undef remainderl 1013 #undef remquo 1014 #undef remquof 1015 #undef remquol 1016 #undef rint 1017 #undef rintf 1018 #undef rintl 1019 #undef round 1020 #undef roundf 1021 #undef roundl 1022 #undef scalbln 1023 #undef scalblnf 1024 #undef scalblnl 1025 #undef scalbn 1026 #undef scalbnf 1027 #undef scalbnl 1028 #undef tgamma 1029 #undef tgammaf 1030 #undef tgammal 1031 #undef trunc 1032 #undef truncf 1033 #undef truncl 1034 1035 namespace std _GLIBCXX_VISIBILITY(default) 1036 { 1037 _GLIBCXX_BEGIN_NAMESPACE_VERSION 1038 1039 // types 1040 using ::double_t; 1041 using ::float_t; 1042 1043 // functions 1044 using ::acosh; 1045 using ::acoshf; 1046 using ::acoshl; 1047 1048 using ::asinh; 1049 using ::asinhf; 1050 using ::asinhl; 1051 1052 using ::atanh; 1053 using ::atanhf; 1054 using ::atanhl; 1055 1056 using ::cbrt; 1057 using ::cbrtf; 1058 using ::cbrtl; 1059 1060 using ::copysign; 1061 using ::copysignf; 1062 using ::copysignl; 1063 1064 using ::erf; 1065 using ::erff; 1066 using ::erfl; 1067 1068 using ::erfc; 1069 using ::erfcf; 1070 using ::erfcl; 1071 1072 using ::exp2; 1073 using ::exp2f; 1074 using ::exp2l; 1075 1076 using ::expm1; 1077 using ::expm1f; 1078 using ::expm1l; 1079 1080 using ::fdim; 1081 using ::fdimf; 1082 using ::fdiml; 1083 1084 using ::fma; 1085 using ::fmaf; 1086 using ::fmal; 1087 1088 using ::fmax; 1089 using ::fmaxf; 1090 using ::fmaxl; 1091 1092 using ::fmin; 1093 using ::fminf; 1094 using ::fminl; 1095 1096 using ::hypot; 1097 using ::hypotf; 1098 using ::hypotl; 1099 1100 using ::ilogb; 1101 using ::ilogbf; 1102 using ::ilogbl; 1103 1104 using ::lgamma; 1105 using ::lgammaf; 1106 using ::lgammal; 1107 1108 using ::llrint; 1109 using ::llrintf; 1110 using ::llrintl; 1111 1112 using ::llround; 1113 using ::llroundf; 1114 using ::llroundl; 1115 1116 using ::log1p; 1117 using ::log1pf; 1118 using ::log1pl; 1119 1120 using ::log2; 1121 using ::log2f; 1122 using ::log2l; 1123 1124 using ::logb; 1125 using ::logbf; 1126 using ::logbl; 1127 1128 using ::lrint; 1129 using ::lrintf; 1130 using ::lrintl; 1131 1132 using ::lround; 1133 using ::lroundf; 1134 using ::lroundl; 1135 1136 using ::nan; 1137 using ::nanf; 1138 using ::nanl; 1139 1140 using ::nearbyint; 1141 using ::nearbyintf; 1142 using ::nearbyintl; 1143 1144 using ::nextafter; 1145 using ::nextafterf; 1146 using ::nextafterl; 1147 1148 using ::nexttoward; 1149 using ::nexttowardf; 1150 using ::nexttowardl; 1151 1152 using ::remainder; 1153 using ::remainderf; 1154 using ::remainderl; 1155 1156 using ::remquo; 1157 using ::remquof; 1158 using ::remquol; 1159 1160 using ::rint; 1161 using ::rintf; 1162 using ::rintl; 1163 1164 using ::round; 1165 using ::roundf; 1166 using ::roundl; 1167 1168 using ::scalbln; 1169 using ::scalblnf; 1170 using ::scalblnl; 1171 1172 using ::scalbn; 1173 using ::scalbnf; 1174 using ::scalbnl; 1175 1176 using ::tgamma; 1177 using ::tgammaf; 1178 using ::tgammal; 1179 1180 using ::trunc; 1181 using ::truncf; 1182 using ::truncl; 1183 1184 /// Additional overloads. 1185 constexpr float 1186 acosh(float __x) 1187 { return __builtin_acoshf(__x); } 1188 1189 constexpr long double 1190 acosh(long double __x) 1191 { return __builtin_acoshl(__x); } 1192 1193 template<typename _Tp> 1194 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1195 double>::__type 1196 acosh(_Tp __x) 1197 { return __builtin_acosh(__x); } 1198 1199 constexpr float 1200 asinh(float __x) 1201 { return __builtin_asinhf(__x); } 1202 1203 constexpr long double 1204 asinh(long double __x) 1205 { return __builtin_asinhl(__x); } 1206 1207 template<typename _Tp> 1208 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1209 double>::__type 1210 asinh(_Tp __x) 1211 { return __builtin_asinh(__x); } 1212 1213 constexpr float 1214 atanh(float __x) 1215 { return __builtin_atanhf(__x); } 1216 1217 constexpr long double 1218 atanh(long double __x) 1219 { return __builtin_atanhl(__x); } 1220 1221 template<typename _Tp> 1222 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1223 double>::__type 1224 atanh(_Tp __x) 1225 { return __builtin_atanh(__x); } 1226 1227 constexpr float 1228 cbrt(float __x) 1229 { return __builtin_cbrtf(__x); } 1230 1231 constexpr long double 1232 cbrt(long double __x) 1233 { return __builtin_cbrtl(__x); } 1234 1235 template<typename _Tp> 1236 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1237 double>::__type 1238 cbrt(_Tp __x) 1239 { return __builtin_cbrt(__x); } 1240 1241 constexpr float 1242 copysign(float __x, float __y) 1243 { return __builtin_copysignf(__x, __y); } 1244 1245 constexpr long double 1246 copysign(long double __x, long double __y) 1247 { return __builtin_copysignl(__x, __y); } 1248 1249 template<typename _Tp, typename _Up> 1250 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1251 copysign(_Tp __x, _Up __y) 1252 { 1253 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1254 return copysign(__type(__x), __type(__y)); 1255 } 1256 1257 constexpr float 1258 erf(float __x) 1259 { return __builtin_erff(__x); } 1260 1261 constexpr long double 1262 erf(long double __x) 1263 { return __builtin_erfl(__x); } 1264 1265 template<typename _Tp> 1266 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1267 double>::__type 1268 erf(_Tp __x) 1269 { return __builtin_erf(__x); } 1270 1271 constexpr float 1272 erfc(float __x) 1273 { return __builtin_erfcf(__x); } 1274 1275 constexpr long double 1276 erfc(long double __x) 1277 { return __builtin_erfcl(__x); } 1278 1279 template<typename _Tp> 1280 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1281 double>::__type 1282 erfc(_Tp __x) 1283 { return __builtin_erfc(__x); } 1284 1285 constexpr float 1286 exp2(float __x) 1287 { return __builtin_exp2f(__x); } 1288 1289 constexpr long double 1290 exp2(long double __x) 1291 { return __builtin_exp2l(__x); } 1292 1293 template<typename _Tp> 1294 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1295 double>::__type 1296 exp2(_Tp __x) 1297 { return __builtin_exp2(__x); } 1298 1299 constexpr float 1300 expm1(float __x) 1301 { return __builtin_expm1f(__x); } 1302 1303 constexpr long double 1304 expm1(long double __x) 1305 { return __builtin_expm1l(__x); } 1306 1307 template<typename _Tp> 1308 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1309 double>::__type 1310 expm1(_Tp __x) 1311 { return __builtin_expm1(__x); } 1312 1313 constexpr float 1314 fdim(float __x, float __y) 1315 { return __builtin_fdimf(__x, __y); } 1316 1317 constexpr long double 1318 fdim(long double __x, long double __y) 1319 { return __builtin_fdiml(__x, __y); } 1320 1321 template<typename _Tp, typename _Up> 1322 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1323 fdim(_Tp __x, _Up __y) 1324 { 1325 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1326 return fdim(__type(__x), __type(__y)); 1327 } 1328 1329 constexpr float 1330 fma(float __x, float __y, float __z) 1331 { return __builtin_fmaf(__x, __y, __z); } 1332 1333 constexpr long double 1334 fma(long double __x, long double __y, long double __z) 1335 { return __builtin_fmal(__x, __y, __z); } 1336 1337 template<typename _Tp, typename _Up, typename _Vp> 1338 constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type 1339 fma(_Tp __x, _Up __y, _Vp __z) 1340 { 1341 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; 1342 return fma(__type(__x), __type(__y), __type(__z)); 1343 } 1344 1345 constexpr float 1346 fmax(float __x, float __y) 1347 { return __builtin_fmaxf(__x, __y); } 1348 1349 constexpr long double 1350 fmax(long double __x, long double __y) 1351 { return __builtin_fmaxl(__x, __y); } 1352 1353 template<typename _Tp, typename _Up> 1354 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1355 fmax(_Tp __x, _Up __y) 1356 { 1357 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1358 return fmax(__type(__x), __type(__y)); 1359 } 1360 1361 constexpr float 1362 fmin(float __x, float __y) 1363 { return __builtin_fminf(__x, __y); } 1364 1365 constexpr long double 1366 fmin(long double __x, long double __y) 1367 { return __builtin_fminl(__x, __y); } 1368 1369 template<typename _Tp, typename _Up> 1370 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1371 fmin(_Tp __x, _Up __y) 1372 { 1373 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1374 return fmin(__type(__x), __type(__y)); 1375 } 1376 1377 constexpr float 1378 hypot(float __x, float __y) 1379 { return __builtin_hypotf(__x, __y); } 1380 1381 constexpr long double 1382 hypot(long double __x, long double __y) 1383 { return __builtin_hypotl(__x, __y); } 1384 1385 template<typename _Tp, typename _Up> 1386 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1387 hypot(_Tp __x, _Up __y) 1388 { 1389 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1390 return hypot(__type(__x), __type(__y)); 1391 } 1392 1393 constexpr int 1394 ilogb(float __x) 1395 { return __builtin_ilogbf(__x); } 1396 1397 constexpr int 1398 ilogb(long double __x) 1399 { return __builtin_ilogbl(__x); } 1400 1401 template<typename _Tp> 1402 constexpr 1403 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1404 int>::__type 1405 ilogb(_Tp __x) 1406 { return __builtin_ilogb(__x); } 1407 1408 constexpr float 1409 lgamma(float __x) 1410 { return __builtin_lgammaf(__x); } 1411 1412 constexpr long double 1413 lgamma(long double __x) 1414 { return __builtin_lgammal(__x); } 1415 1416 template<typename _Tp> 1417 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1418 double>::__type 1419 lgamma(_Tp __x) 1420 { return __builtin_lgamma(__x); } 1421 1422 constexpr long long 1423 llrint(float __x) 1424 { return __builtin_llrintf(__x); } 1425 1426 constexpr long long 1427 llrint(long double __x) 1428 { return __builtin_llrintl(__x); } 1429 1430 template<typename _Tp> 1431 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1432 long long>::__type 1433 llrint(_Tp __x) 1434 { return __builtin_llrint(__x); } 1435 1436 constexpr long long 1437 llround(float __x) 1438 { return __builtin_llroundf(__x); } 1439 1440 constexpr long long 1441 llround(long double __x) 1442 { return __builtin_llroundl(__x); } 1443 1444 template<typename _Tp> 1445 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1446 long long>::__type 1447 llround(_Tp __x) 1448 { return __builtin_llround(__x); } 1449 1450 constexpr float 1451 log1p(float __x) 1452 { return __builtin_log1pf(__x); } 1453 1454 constexpr long double 1455 log1p(long double __x) 1456 { return __builtin_log1pl(__x); } 1457 1458 template<typename _Tp> 1459 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1460 double>::__type 1461 log1p(_Tp __x) 1462 { return __builtin_log1p(__x); } 1463 1464 // DR 568. 1465 constexpr float 1466 log2(float __x) 1467 { return __builtin_log2f(__x); } 1468 1469 constexpr long double 1470 log2(long double __x) 1471 { return __builtin_log2l(__x); } 1472 1473 template<typename _Tp> 1474 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1475 double>::__type 1476 log2(_Tp __x) 1477 { return __builtin_log2(__x); } 1478 1479 constexpr float 1480 logb(float __x) 1481 { return __builtin_logbf(__x); } 1482 1483 constexpr long double 1484 logb(long double __x) 1485 { return __builtin_logbl(__x); } 1486 1487 template<typename _Tp> 1488 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1489 double>::__type 1490 logb(_Tp __x) 1491 { return __builtin_logb(__x); } 1492 1493 constexpr long 1494 lrint(float __x) 1495 { return __builtin_lrintf(__x); } 1496 1497 constexpr long 1498 lrint(long double __x) 1499 { return __builtin_lrintl(__x); } 1500 1501 template<typename _Tp> 1502 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1503 long>::__type 1504 lrint(_Tp __x) 1505 { return __builtin_lrint(__x); } 1506 1507 constexpr long 1508 lround(float __x) 1509 { return __builtin_lroundf(__x); } 1510 1511 constexpr long 1512 lround(long double __x) 1513 { return __builtin_lroundl(__x); } 1514 1515 template<typename _Tp> 1516 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1517 long>::__type 1518 lround(_Tp __x) 1519 { return __builtin_lround(__x); } 1520 1521 constexpr float 1522 nearbyint(float __x) 1523 { return __builtin_nearbyintf(__x); } 1524 1525 constexpr long double 1526 nearbyint(long double __x) 1527 { return __builtin_nearbyintl(__x); } 1528 1529 template<typename _Tp> 1530 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1531 double>::__type 1532 nearbyint(_Tp __x) 1533 { return __builtin_nearbyint(__x); } 1534 1535 constexpr float 1536 nextafter(float __x, float __y) 1537 { return __builtin_nextafterf(__x, __y); } 1538 1539 constexpr long double 1540 nextafter(long double __x, long double __y) 1541 { return __builtin_nextafterl(__x, __y); } 1542 1543 template<typename _Tp, typename _Up> 1544 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1545 nextafter(_Tp __x, _Up __y) 1546 { 1547 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1548 return nextafter(__type(__x), __type(__y)); 1549 } 1550 1551 constexpr float 1552 nexttoward(float __x, long double __y) 1553 { return __builtin_nexttowardf(__x, __y); } 1554 1555 constexpr long double 1556 nexttoward(long double __x, long double __y) 1557 { return __builtin_nexttowardl(__x, __y); } 1558 1559 template<typename _Tp> 1560 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1561 double>::__type 1562 nexttoward(_Tp __x, long double __y) 1563 { return __builtin_nexttoward(__x, __y); } 1564 1565 constexpr float 1566 remainder(float __x, float __y) 1567 { return __builtin_remainderf(__x, __y); } 1568 1569 constexpr long double 1570 remainder(long double __x, long double __y) 1571 { return __builtin_remainderl(__x, __y); } 1572 1573 template<typename _Tp, typename _Up> 1574 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1575 remainder(_Tp __x, _Up __y) 1576 { 1577 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1578 return remainder(__type(__x), __type(__y)); 1579 } 1580 1581 inline float 1582 remquo(float __x, float __y, int* __pquo) 1583 { return __builtin_remquof(__x, __y, __pquo); } 1584 1585 inline long double 1586 remquo(long double __x, long double __y, int* __pquo) 1587 { return __builtin_remquol(__x, __y, __pquo); } 1588 1589 template<typename _Tp, typename _Up> 1590 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1591 remquo(_Tp __x, _Up __y, int* __pquo) 1592 { 1593 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1594 return remquo(__type(__x), __type(__y), __pquo); 1595 } 1596 1597 constexpr float 1598 rint(float __x) 1599 { return __builtin_rintf(__x); } 1600 1601 constexpr long double 1602 rint(long double __x) 1603 { return __builtin_rintl(__x); } 1604 1605 template<typename _Tp> 1606 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1607 double>::__type 1608 rint(_Tp __x) 1609 { return __builtin_rint(__x); } 1610 1611 constexpr float 1612 round(float __x) 1613 { return __builtin_roundf(__x); } 1614 1615 constexpr long double 1616 round(long double __x) 1617 { return __builtin_roundl(__x); } 1618 1619 template<typename _Tp> 1620 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1621 double>::__type 1622 round(_Tp __x) 1623 { return __builtin_round(__x); } 1624 1625 constexpr float 1626 scalbln(float __x, long __ex) 1627 { return __builtin_scalblnf(__x, __ex); } 1628 1629 constexpr long double 1630 scalbln(long double __x, long __ex) 1631 { return __builtin_scalblnl(__x, __ex); } 1632 1633 template<typename _Tp> 1634 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1635 double>::__type 1636 scalbln(_Tp __x, long __ex) 1637 { return __builtin_scalbln(__x, __ex); } 1638 1639 constexpr float 1640 scalbn(float __x, int __ex) 1641 { return __builtin_scalbnf(__x, __ex); } 1642 1643 constexpr long double 1644 scalbn(long double __x, int __ex) 1645 { return __builtin_scalbnl(__x, __ex); } 1646 1647 template<typename _Tp> 1648 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1649 double>::__type 1650 scalbn(_Tp __x, int __ex) 1651 { return __builtin_scalbn(__x, __ex); } 1652 1653 constexpr float 1654 tgamma(float __x) 1655 { return __builtin_tgammaf(__x); } 1656 1657 constexpr long double 1658 tgamma(long double __x) 1659 { return __builtin_tgammal(__x); } 1660 1661 template<typename _Tp> 1662 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1663 double>::__type 1664 tgamma(_Tp __x) 1665 { return __builtin_tgamma(__x); } 1666 1667 constexpr float 1668 trunc(float __x) 1669 { return __builtin_truncf(__x); } 1670 1671 constexpr long double 1672 trunc(long double __x) 1673 { return __builtin_truncl(__x); } 1674 1675 template<typename _Tp> 1676 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1677 double>::__type 1678 trunc(_Tp __x) 1679 { return __builtin_trunc(__x); } 1680 1681 _GLIBCXX_END_NAMESPACE_VERSION 1682 } // namespace 1683 1684 #endif // _GLIBCXX_USE_C99_MATH_TR1 1685 1686 #endif // __GXX_EXPERIMENTAL_CXX0X__ 1687 1688 #endif 1689
