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