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_FP 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#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 579 template<typename _Tp> 580 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 581 int>::__type 582 fpclassify(_Tp __x) 583 { return __x != 0 ? FP_NORMAL : FP_ZERO; } 584#endif 585 586#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 587 constexpr bool 588 isfinite(float __x) 589 { return __builtin_isfinite(__x); } 590 591 constexpr bool 592 isfinite(double __x) 593 { return __builtin_isfinite(__x); } 594 595 constexpr bool 596 isfinite(long double __x) 597 { return __builtin_isfinite(__x); } 598#endif 599 600#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 601 template<typename _Tp> 602 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 603 bool>::__type 604 isfinite(_Tp __x) 605 { return true; } 606#endif 607 608#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 609 constexpr bool 610 isinf(float __x) 611 { return __builtin_isinf(__x); } 612 613 constexpr bool 614 isinf(double __x) 615 { return __builtin_isinf(__x); } 616 617 constexpr bool 618 isinf(long double __x) 619 { return __builtin_isinf(__x); } 620#endif 621 622#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 623 template<typename _Tp> 624 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 625 bool>::__type 626 isinf(_Tp __x) 627 { return false; } 628#endif 629 630#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 631 constexpr bool 632 isnan(float __x) 633 { return __builtin_isnan(__x); } 634 635 constexpr bool 636 isnan(double __x) 637 { return __builtin_isnan(__x); } 638 639 constexpr bool 640 isnan(long double __x) 641 { return __builtin_isnan(__x); } 642#endif 643 644#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 645 template<typename _Tp> 646 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 647 bool>::__type 648 isnan(_Tp __x) 649 { return false; } 650#endif 651 652#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 653 constexpr bool 654 isnormal(float __x) 655 { return __builtin_isnormal(__x); } 656 657 constexpr bool 658 isnormal(double __x) 659 { return __builtin_isnormal(__x); } 660 661 constexpr bool 662 isnormal(long double __x) 663 { return __builtin_isnormal(__x); } 664#endif 665 666#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 667 template<typename _Tp> 668 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 669 bool>::__type 670 isnormal(_Tp __x) 671 { return __x != 0 ? true : false; } 672#endif 673 674#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 675 // The front-end doesn't provide a type generic builtin (libstdc++/58625). 676 constexpr bool 677 signbit(float __x) 678 { return __builtin_signbitf(__x); } 679 680 constexpr bool 681 signbit(double __x) 682 { return __builtin_signbit(__x); } 683 684 constexpr bool 685 signbit(long double __x) 686 { return __builtin_signbitl(__x); } 687#endif 688 689#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 690 template<typename _Tp> 691 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 692 bool>::__type 693 signbit(_Tp __x) 694 { return __x < 0 ? true : false; } 695#endif 696 697#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 698 constexpr bool 699 isgreater(float __x, float __y) 700 { return __builtin_isgreater(__x, __y); } 701 702 constexpr bool 703 isgreater(double __x, double __y) 704 { return __builtin_isgreater(__x, __y); } 705 706 constexpr bool 707 isgreater(long double __x, long double __y) 708 { return __builtin_isgreater(__x, __y); } 709#endif 710 711#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 712 template<typename _Tp, typename _Up> 713 constexpr typename 714 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 715 && __is_arithmetic<_Up>::__value), bool>::__type 716 isgreater(_Tp __x, _Up __y) 717 { 718 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 719 return __builtin_isgreater(__type(__x), __type(__y)); 720 } 721#endif 722 723#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 724 constexpr bool 725 isgreaterequal(float __x, float __y) 726 { return __builtin_isgreaterequal(__x, __y); } 727 728 constexpr bool 729 isgreaterequal(double __x, double __y) 730 { return __builtin_isgreaterequal(__x, __y); } 731 732 constexpr bool 733 isgreaterequal(long double __x, long double __y) 734 { return __builtin_isgreaterequal(__x, __y); } 735#endif 736 737#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 738 template<typename _Tp, typename _Up> 739 constexpr typename 740 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 741 && __is_arithmetic<_Up>::__value), bool>::__type 742 isgreaterequal(_Tp __x, _Up __y) 743 { 744 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 745 return __builtin_isgreaterequal(__type(__x), __type(__y)); 746 } 747#endif 748 749#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 750 constexpr bool 751 isless(float __x, float __y) 752 { return __builtin_isless(__x, __y); } 753 754 constexpr bool 755 isless(double __x, double __y) 756 { return __builtin_isless(__x, __y); } 757 758 constexpr bool 759 isless(long double __x, long double __y) 760 { return __builtin_isless(__x, __y); } 761#endif 762 763#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 764 template<typename _Tp, typename _Up> 765 constexpr typename 766 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 767 && __is_arithmetic<_Up>::__value), bool>::__type 768 isless(_Tp __x, _Up __y) 769 { 770 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 771 return __builtin_isless(__type(__x), __type(__y)); 772 } 773#endif 774 775#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 776 constexpr bool 777 islessequal(float __x, float __y) 778 { return __builtin_islessequal(__x, __y); } 779 780 constexpr bool 781 islessequal(double __x, double __y) 782 { return __builtin_islessequal(__x, __y); } 783 784 constexpr bool 785 islessequal(long double __x, long double __y) 786 { return __builtin_islessequal(__x, __y); } 787#endif 788 789#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 790 template<typename _Tp, typename _Up> 791 constexpr typename 792 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 793 && __is_arithmetic<_Up>::__value), bool>::__type 794 islessequal(_Tp __x, _Up __y) 795 { 796 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 797 return __builtin_islessequal(__type(__x), __type(__y)); 798 } 799#endif 800 801#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 802 constexpr bool 803 islessgreater(float __x, float __y) 804 { return __builtin_islessgreater(__x, __y); } 805 806 constexpr bool 807 islessgreater(double __x, double __y) 808 { return __builtin_islessgreater(__x, __y); } 809 810 constexpr bool 811 islessgreater(long double __x, long double __y) 812 { return __builtin_islessgreater(__x, __y); } 813#endif 814 815#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 816 template<typename _Tp, typename _Up> 817 constexpr typename 818 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 819 && __is_arithmetic<_Up>::__value), bool>::__type 820 islessgreater(_Tp __x, _Up __y) 821 { 822 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 823 return __builtin_islessgreater(__type(__x), __type(__y)); 824 } 825#endif 826 827#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 828 constexpr bool 829 isunordered(float __x, float __y) 830 { return __builtin_isunordered(__x, __y); } 831 832 constexpr bool 833 isunordered(double __x, double __y) 834 { return __builtin_isunordered(__x, __y); } 835 836 constexpr bool 837 isunordered(long double __x, long double __y) 838 { return __builtin_isunordered(__x, __y); } 839#endif 840 841#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 842 template<typename _Tp, typename _Up> 843 constexpr typename 844 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 845 && __is_arithmetic<_Up>::__value), bool>::__type 846 isunordered(_Tp __x, _Up __y) 847 { 848 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 849 return __builtin_isunordered(__type(__x), __type(__y)); 850 } 851#endif 852 853#else 854 855 template<typename _Tp> 856 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 857 int>::__type 858 fpclassify(_Tp __f) 859 { 860 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 861 return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 862 FP_SUBNORMAL, FP_ZERO, __type(__f)); 863 } 864 865 template<typename _Tp> 866 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 867 int>::__type 868 isfinite(_Tp __f) 869 { 870 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 871 return __builtin_isfinite(__type(__f)); 872 } 873 874 template<typename _Tp> 875 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 876 int>::__type 877 isinf(_Tp __f) 878 { 879 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 880 return __builtin_isinf(__type(__f)); 881 } 882 883 template<typename _Tp> 884 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 885 int>::__type 886 isnan(_Tp __f) 887 { 888 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 889 return __builtin_isnan(__type(__f)); 890 } 891 892 template<typename _Tp> 893 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 894 int>::__type 895 isnormal(_Tp __f) 896 { 897 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 898 return __builtin_isnormal(__type(__f)); 899 } 900 901 template<typename _Tp> 902 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 903 int>::__type 904 signbit(_Tp __f) 905 { 906 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 907 return sizeof(__type) == sizeof(float) 908 ? __builtin_signbitf(__type(__f)) 909 : sizeof(__type) == sizeof(double) 910 ? __builtin_signbit(__type(__f)) 911 : __builtin_signbitl(__type(__f)); 912 } 913 914 template<typename _Tp> 915 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 916 int>::__type 917 isgreater(_Tp __f1, _Tp __f2) 918 { 919 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 920 return __builtin_isgreater(__type(__f1), __type(__f2)); 921 } 922 923 template<typename _Tp> 924 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 925 int>::__type 926 isgreaterequal(_Tp __f1, _Tp __f2) 927 { 928 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 929 return __builtin_isgreaterequal(__type(__f1), __type(__f2)); 930 } 931 932 template<typename _Tp> 933 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 934 int>::__type 935 isless(_Tp __f1, _Tp __f2) 936 { 937 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 938 return __builtin_isless(__type(__f1), __type(__f2)); 939 } 940 941 template<typename _Tp> 942 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 943 int>::__type 944 islessequal(_Tp __f1, _Tp __f2) 945 { 946 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 947 return __builtin_islessequal(__type(__f1), __type(__f2)); 948 } 949 950 template<typename _Tp> 951 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 952 int>::__type 953 islessgreater(_Tp __f1, _Tp __f2) 954 { 955 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 956 return __builtin_islessgreater(__type(__f1), __type(__f2)); 957 } 958 959 template<typename _Tp> 960 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 961 int>::__type 962 isunordered(_Tp __f1, _Tp __f2) 963 { 964 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 965 return __builtin_isunordered(__type(__f1), __type(__f2)); 966 } 967 968#endif 969 970_GLIBCXX_END_NAMESPACE_VERSION 971} // namespace 972 973#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ 974#endif 975 976#if __cplusplus >= 201103L 977 978#ifdef _GLIBCXX_USE_C99_MATH_TR1 979 980#undef acosh 981#undef acoshf 982#undef acoshl 983#undef asinh 984#undef asinhf 985#undef asinhl 986#undef atanh 987#undef atanhf 988#undef atanhl 989#undef cbrt 990#undef cbrtf 991#undef cbrtl 992#undef copysign 993#undef copysignf 994#undef copysignl 995#undef erf 996#undef erff 997#undef erfl 998#undef erfc 999#undef erfcf 1000#undef erfcl 1001#undef exp2 1002#undef exp2f 1003#undef exp2l 1004#undef expm1 1005#undef expm1f 1006#undef expm1l 1007#undef fdim 1008#undef fdimf 1009#undef fdiml 1010#undef fma 1011#undef fmaf 1012#undef fmal 1013#undef fmax 1014#undef fmaxf 1015#undef fmaxl 1016#undef fmin 1017#undef fminf 1018#undef fminl 1019#undef hypot 1020#undef hypotf 1021#undef hypotl 1022#undef ilogb 1023#undef ilogbf 1024#undef ilogbl 1025#undef lgamma 1026#undef lgammaf 1027#undef lgammal 1028#undef llrint 1029#undef llrintf 1030#undef llrintl 1031#undef llround 1032#undef llroundf 1033#undef llroundl 1034#undef log1p 1035#undef log1pf 1036#undef log1pl 1037#undef log2 1038#undef log2f 1039#undef log2l 1040#undef logb 1041#undef logbf 1042#undef logbl 1043#undef lrint 1044#undef lrintf 1045#undef lrintl 1046#undef lround 1047#undef lroundf 1048#undef lroundl 1049#undef nan 1050#undef nanf 1051#undef nanl 1052#undef nearbyint 1053#undef nearbyintf 1054#undef nearbyintl 1055#undef nextafter 1056#undef nextafterf 1057#undef nextafterl 1058#undef nexttoward 1059#undef nexttowardf 1060#undef nexttowardl 1061#undef remainder 1062#undef remainderf 1063#undef remainderl 1064#undef remquo 1065#undef remquof 1066#undef remquol 1067#undef rint 1068#undef rintf 1069#undef rintl 1070#undef round 1071#undef roundf 1072#undef roundl 1073#undef scalbln 1074#undef scalblnf 1075#undef scalblnl 1076#undef scalbn 1077#undef scalbnf 1078#undef scalbnl 1079#undef tgamma 1080#undef tgammaf 1081#undef tgammal 1082#undef trunc 1083#undef truncf 1084#undef truncl 1085 1086namespace std _GLIBCXX_VISIBILITY(default) 1087{ 1088_GLIBCXX_BEGIN_NAMESPACE_VERSION 1089 1090 // types 1091 using ::double_t; 1092 using ::float_t; 1093 1094 // functions 1095 using ::acosh; 1096 using ::acoshf; 1097 using ::acoshl; 1098 1099 using ::asinh; 1100 using ::asinhf; 1101 using ::asinhl; 1102 1103 using ::atanh; 1104 using ::atanhf; 1105 using ::atanhl; 1106 1107 using ::cbrt; 1108 using ::cbrtf; 1109 using ::cbrtl; 1110 1111 using ::copysign; 1112 using ::copysignf; 1113 using ::copysignl; 1114 1115 using ::erf; 1116 using ::erff; 1117 using ::erfl; 1118 1119 using ::erfc; 1120 using ::erfcf; 1121 using ::erfcl; 1122 1123 using ::exp2; 1124 using ::exp2f; 1125 using ::exp2l; 1126 1127 using ::expm1; 1128 using ::expm1f; 1129 using ::expm1l; 1130 1131 using ::fdim; 1132 using ::fdimf; 1133 using ::fdiml; 1134 1135 using ::fma; 1136 using ::fmaf; 1137 using ::fmal; 1138 1139 using ::fmax; 1140 using ::fmaxf; 1141 using ::fmaxl; 1142 1143 using ::fmin; 1144 using ::fminf; 1145 using ::fminl; 1146 1147 using ::hypot; 1148 using ::hypotf; 1149 using ::hypotl; 1150 1151 using ::ilogb; 1152 using ::ilogbf; 1153 using ::ilogbl; 1154 1155 using ::lgamma; 1156 using ::lgammaf; 1157 using ::lgammal; 1158 1159 using ::llrint; 1160 using ::llrintf; 1161 using ::llrintl; 1162 1163 using ::llround; 1164 using ::llroundf; 1165 using ::llroundl; 1166 1167 using ::log1p; 1168 using ::log1pf; 1169 using ::log1pl; 1170 1171 using ::log2; 1172 using ::log2f; 1173 using ::log2l; 1174 1175 using ::logb; 1176 using ::logbf; 1177 using ::logbl; 1178 1179 using ::lrint; 1180 using ::lrintf; 1181 using ::lrintl; 1182 1183 using ::lround; 1184 using ::lroundf; 1185 using ::lroundl; 1186 1187 using ::nan; 1188 using ::nanf; 1189 using ::nanl; 1190 1191 using ::nearbyint; 1192 using ::nearbyintf; 1193 using ::nearbyintl; 1194 1195 using ::nextafter; 1196 using ::nextafterf; 1197 using ::nextafterl; 1198 1199 using ::nexttoward; 1200 using ::nexttowardf; 1201 using ::nexttowardl; 1202 1203 using ::remainder; 1204 using ::remainderf; 1205 using ::remainderl; 1206 1207 using ::remquo; 1208 using ::remquof; 1209 using ::remquol; 1210 1211 using ::rint; 1212 using ::rintf; 1213 using ::rintl; 1214 1215 using ::round; 1216 using ::roundf; 1217 using ::roundl; 1218 1219 using ::scalbln; 1220 using ::scalblnf; 1221 using ::scalblnl; 1222 1223 using ::scalbn; 1224 using ::scalbnf; 1225 using ::scalbnl; 1226 1227 using ::tgamma; 1228 using ::tgammaf; 1229 using ::tgammal; 1230 1231 using ::trunc; 1232 using ::truncf; 1233 using ::truncl; 1234 1235 /// Additional overloads. 1236#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1237 constexpr float 1238 acosh(float __x) 1239 { return __builtin_acoshf(__x); } 1240 1241 constexpr long double 1242 acosh(long double __x) 1243 { return __builtin_acoshl(__x); } 1244#endif 1245 1246#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1247 template<typename _Tp> 1248 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1249 double>::__type 1250 acosh(_Tp __x) 1251 { return __builtin_acosh(__x); } 1252#endif 1253 1254#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1255 constexpr float 1256 asinh(float __x) 1257 { return __builtin_asinhf(__x); } 1258 1259 constexpr long double 1260 asinh(long double __x) 1261 { return __builtin_asinhl(__x); } 1262#endif 1263 1264#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1265 template<typename _Tp> 1266 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1267 double>::__type 1268 asinh(_Tp __x) 1269 { return __builtin_asinh(__x); } 1270#endif 1271 1272#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1273 constexpr float 1274 atanh(float __x) 1275 { return __builtin_atanhf(__x); } 1276 1277 constexpr long double 1278 atanh(long double __x) 1279 { return __builtin_atanhl(__x); } 1280#endif 1281 1282#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1283 template<typename _Tp> 1284 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1285 double>::__type 1286 atanh(_Tp __x) 1287 { return __builtin_atanh(__x); } 1288#endif 1289 1290#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1291 constexpr float 1292 cbrt(float __x) 1293 { return __builtin_cbrtf(__x); } 1294 1295 constexpr long double 1296 cbrt(long double __x) 1297 { return __builtin_cbrtl(__x); } 1298#endif 1299 1300#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1301 template<typename _Tp> 1302 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1303 double>::__type 1304 cbrt(_Tp __x) 1305 { return __builtin_cbrt(__x); } 1306#endif 1307 1308#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1309 constexpr float 1310 copysign(float __x, float __y) 1311 { return __builtin_copysignf(__x, __y); } 1312 1313 constexpr long double 1314 copysign(long double __x, long double __y) 1315 { return __builtin_copysignl(__x, __y); } 1316#endif 1317 1318#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1319 template<typename _Tp, typename _Up> 1320 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1321 copysign(_Tp __x, _Up __y) 1322 { 1323 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1324 return copysign(__type(__x), __type(__y)); 1325 } 1326#endif 1327 1328#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1329 constexpr float 1330 erf(float __x) 1331 { return __builtin_erff(__x); } 1332 1333 constexpr long double 1334 erf(long double __x) 1335 { return __builtin_erfl(__x); } 1336#endif 1337 1338#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1339 template<typename _Tp> 1340 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1341 double>::__type 1342 erf(_Tp __x) 1343 { return __builtin_erf(__x); } 1344#endif 1345 1346#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1347 constexpr float 1348 erfc(float __x) 1349 { return __builtin_erfcf(__x); } 1350 1351 constexpr long double 1352 erfc(long double __x) 1353 { return __builtin_erfcl(__x); } 1354#endif 1355 1356#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1357 template<typename _Tp> 1358 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1359 double>::__type 1360 erfc(_Tp __x) 1361 { return __builtin_erfc(__x); } 1362#endif 1363 1364#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1365 constexpr float 1366 exp2(float __x) 1367 { return __builtin_exp2f(__x); } 1368 1369 constexpr long double 1370 exp2(long double __x) 1371 { return __builtin_exp2l(__x); } 1372#endif 1373 1374#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1375 template<typename _Tp> 1376 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1377 double>::__type 1378 exp2(_Tp __x) 1379 { return __builtin_exp2(__x); } 1380#endif 1381 1382#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1383 constexpr float 1384 expm1(float __x) 1385 { return __builtin_expm1f(__x); } 1386 1387 constexpr long double 1388 expm1(long double __x) 1389 { return __builtin_expm1l(__x); } 1390#endif 1391 1392#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1393 template<typename _Tp> 1394 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1395 double>::__type 1396 expm1(_Tp __x) 1397 { return __builtin_expm1(__x); } 1398#endif 1399 1400#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1401 constexpr float 1402 fdim(float __x, float __y) 1403 { return __builtin_fdimf(__x, __y); } 1404 1405 constexpr long double 1406 fdim(long double __x, long double __y) 1407 { return __builtin_fdiml(__x, __y); } 1408#endif 1409 1410#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1411 template<typename _Tp, typename _Up> 1412 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1413 fdim(_Tp __x, _Up __y) 1414 { 1415 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1416 return fdim(__type(__x), __type(__y)); 1417 } 1418#endif 1419 1420#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1421 constexpr float 1422 fma(float __x, float __y, float __z) 1423 { return __builtin_fmaf(__x, __y, __z); } 1424 1425 constexpr long double 1426 fma(long double __x, long double __y, long double __z) 1427 { return __builtin_fmal(__x, __y, __z); } 1428#endif 1429 1430#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1431 template<typename _Tp, typename _Up, typename _Vp> 1432 constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type 1433 fma(_Tp __x, _Up __y, _Vp __z) 1434 { 1435 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; 1436 return fma(__type(__x), __type(__y), __type(__z)); 1437 } 1438#endif 1439 1440#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1441 constexpr float 1442 fmax(float __x, float __y) 1443 { return __builtin_fmaxf(__x, __y); } 1444 1445 constexpr long double 1446 fmax(long double __x, long double __y) 1447 { return __builtin_fmaxl(__x, __y); } 1448#endif 1449 1450#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1451 template<typename _Tp, typename _Up> 1452 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1453 fmax(_Tp __x, _Up __y) 1454 { 1455 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1456 return fmax(__type(__x), __type(__y)); 1457 } 1458#endif 1459 1460#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1461 constexpr float 1462 fmin(float __x, float __y) 1463 { return __builtin_fminf(__x, __y); } 1464 1465 constexpr long double 1466 fmin(long double __x, long double __y) 1467 { return __builtin_fminl(__x, __y); } 1468#endif 1469 1470#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1471 template<typename _Tp, typename _Up> 1472 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1473 fmin(_Tp __x, _Up __y) 1474 { 1475 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1476 return fmin(__type(__x), __type(__y)); 1477 } 1478#endif 1479 1480#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1481 constexpr float 1482 hypot(float __x, float __y) 1483 { return __builtin_hypotf(__x, __y); } 1484 1485 constexpr long double 1486 hypot(long double __x, long double __y) 1487 { return __builtin_hypotl(__x, __y); } 1488#endif 1489 1490#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1491 template<typename _Tp, typename _Up> 1492 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1493 hypot(_Tp __x, _Up __y) 1494 { 1495 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1496 return hypot(__type(__x), __type(__y)); 1497 } 1498#endif 1499 1500#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1501 constexpr int 1502 ilogb(float __x) 1503 { return __builtin_ilogbf(__x); } 1504 1505 constexpr int 1506 ilogb(long double __x) 1507 { return __builtin_ilogbl(__x); } 1508#endif 1509 1510#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1511 template<typename _Tp> 1512 constexpr 1513 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1514 int>::__type 1515 ilogb(_Tp __x) 1516 { return __builtin_ilogb(__x); } 1517#endif 1518 1519#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1520 constexpr float 1521 lgamma(float __x) 1522 { return __builtin_lgammaf(__x); } 1523 1524 constexpr long double 1525 lgamma(long double __x) 1526 { return __builtin_lgammal(__x); } 1527#endif 1528 1529#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1530 template<typename _Tp> 1531 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1532 double>::__type 1533 lgamma(_Tp __x) 1534 { return __builtin_lgamma(__x); } 1535#endif 1536 1537#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1538 constexpr long long 1539 llrint(float __x) 1540 { return __builtin_llrintf(__x); } 1541 1542 constexpr long long 1543 llrint(long double __x) 1544 { return __builtin_llrintl(__x); } 1545#endif 1546 1547#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1548 template<typename _Tp> 1549 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1550 long long>::__type 1551 llrint(_Tp __x) 1552 { return __builtin_llrint(__x); } 1553#endif 1554 1555#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1556 constexpr long long 1557 llround(float __x) 1558 { return __builtin_llroundf(__x); } 1559 1560 constexpr long long 1561 llround(long double __x) 1562 { return __builtin_llroundl(__x); } 1563#endif 1564 1565#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1566 template<typename _Tp> 1567 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1568 long long>::__type 1569 llround(_Tp __x) 1570 { return __builtin_llround(__x); } 1571#endif 1572 1573#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1574 constexpr float 1575 log1p(float __x) 1576 { return __builtin_log1pf(__x); } 1577 1578 constexpr long double 1579 log1p(long double __x) 1580 { return __builtin_log1pl(__x); } 1581#endif 1582 1583#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1584 template<typename _Tp> 1585 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1586 double>::__type 1587 log1p(_Tp __x) 1588 { return __builtin_log1p(__x); } 1589#endif 1590 1591#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1592 // DR 568. 1593 constexpr float 1594 log2(float __x) 1595 { return __builtin_log2f(__x); } 1596 1597 constexpr long double 1598 log2(long double __x) 1599 { return __builtin_log2l(__x); } 1600#endif 1601 1602#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1603 template<typename _Tp> 1604 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1605 double>::__type 1606 log2(_Tp __x) 1607 { return __builtin_log2(__x); } 1608#endif 1609 1610#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1611 constexpr float 1612 logb(float __x) 1613 { return __builtin_logbf(__x); } 1614 1615 constexpr long double 1616 logb(long double __x) 1617 { return __builtin_logbl(__x); } 1618#endif 1619 1620#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1621 template<typename _Tp> 1622 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1623 double>::__type 1624 logb(_Tp __x) 1625 { return __builtin_logb(__x); } 1626#endif 1627 1628#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1629 constexpr long 1630 lrint(float __x) 1631 { return __builtin_lrintf(__x); } 1632 1633 constexpr long 1634 lrint(long double __x) 1635 { return __builtin_lrintl(__x); } 1636#endif 1637 1638#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1639 template<typename _Tp> 1640 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1641 long>::__type 1642 lrint(_Tp __x) 1643 { return __builtin_lrint(__x); } 1644#endif 1645 1646#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1647 constexpr long 1648 lround(float __x) 1649 { return __builtin_lroundf(__x); } 1650 1651 constexpr long 1652 lround(long double __x) 1653 { return __builtin_lroundl(__x); } 1654#endif 1655 1656#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1657 template<typename _Tp> 1658 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1659 long>::__type 1660 lround(_Tp __x) 1661 { return __builtin_lround(__x); } 1662#endif 1663 1664#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1665 constexpr float 1666 nearbyint(float __x) 1667 { return __builtin_nearbyintf(__x); } 1668 1669 constexpr long double 1670 nearbyint(long double __x) 1671 { return __builtin_nearbyintl(__x); } 1672#endif 1673 1674#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1675 template<typename _Tp> 1676 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1677 double>::__type 1678 nearbyint(_Tp __x) 1679 { return __builtin_nearbyint(__x); } 1680#endif 1681 1682#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1683 constexpr float 1684 nextafter(float __x, float __y) 1685 { return __builtin_nextafterf(__x, __y); } 1686 1687 constexpr long double 1688 nextafter(long double __x, long double __y) 1689 { return __builtin_nextafterl(__x, __y); } 1690#endif 1691 1692#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1693 template<typename _Tp, typename _Up> 1694 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1695 nextafter(_Tp __x, _Up __y) 1696 { 1697 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1698 return nextafter(__type(__x), __type(__y)); 1699 } 1700#endif 1701 1702#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1703 constexpr float 1704 nexttoward(float __x, long double __y) 1705 { return __builtin_nexttowardf(__x, __y); } 1706 1707 constexpr long double 1708 nexttoward(long double __x, long double __y) 1709 { return __builtin_nexttowardl(__x, __y); } 1710#endif 1711 1712#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1713 template<typename _Tp> 1714 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1715 double>::__type 1716 nexttoward(_Tp __x, long double __y) 1717 { return __builtin_nexttoward(__x, __y); } 1718#endif 1719 1720#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1721 constexpr float 1722 remainder(float __x, float __y) 1723 { return __builtin_remainderf(__x, __y); } 1724 1725 constexpr long double 1726 remainder(long double __x, long double __y) 1727 { return __builtin_remainderl(__x, __y); } 1728#endif 1729 1730#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1731 template<typename _Tp, typename _Up> 1732 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1733 remainder(_Tp __x, _Up __y) 1734 { 1735 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1736 return remainder(__type(__x), __type(__y)); 1737 } 1738#endif 1739 1740#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1741 inline float 1742 remquo(float __x, float __y, int* __pquo) 1743 { return __builtin_remquof(__x, __y, __pquo); } 1744 1745 inline long double 1746 remquo(long double __x, long double __y, int* __pquo) 1747 { return __builtin_remquol(__x, __y, __pquo); } 1748#endif 1749 1750#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1751 template<typename _Tp, typename _Up> 1752 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1753 remquo(_Tp __x, _Up __y, int* __pquo) 1754 { 1755 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1756 return remquo(__type(__x), __type(__y), __pquo); 1757 } 1758#endif 1759 1760#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1761 constexpr float 1762 rint(float __x) 1763 { return __builtin_rintf(__x); } 1764 1765 constexpr long double 1766 rint(long double __x) 1767 { return __builtin_rintl(__x); } 1768#endif 1769 1770#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1771 template<typename _Tp> 1772 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1773 double>::__type 1774 rint(_Tp __x) 1775 { return __builtin_rint(__x); } 1776#endif 1777 1778#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1779 constexpr float 1780 round(float __x) 1781 { return __builtin_roundf(__x); } 1782 1783 constexpr long double 1784 round(long double __x) 1785 { return __builtin_roundl(__x); } 1786#endif 1787 1788#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1789 template<typename _Tp> 1790 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1791 double>::__type 1792 round(_Tp __x) 1793 { return __builtin_round(__x); } 1794#endif 1795 1796#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1797 constexpr float 1798 scalbln(float __x, long __ex) 1799 { return __builtin_scalblnf(__x, __ex); } 1800 1801 constexpr long double 1802 scalbln(long double __x, long __ex) 1803 { return __builtin_scalblnl(__x, __ex); } 1804#endif 1805 1806#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1807 template<typename _Tp> 1808 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1809 double>::__type 1810 scalbln(_Tp __x, long __ex) 1811 { return __builtin_scalbln(__x, __ex); } 1812#endif 1813 1814#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1815 constexpr float 1816 scalbn(float __x, int __ex) 1817 { return __builtin_scalbnf(__x, __ex); } 1818 1819 constexpr long double 1820 scalbn(long double __x, int __ex) 1821 { return __builtin_scalbnl(__x, __ex); } 1822#endif 1823 1824#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1825 template<typename _Tp> 1826 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1827 double>::__type 1828 scalbn(_Tp __x, int __ex) 1829 { return __builtin_scalbn(__x, __ex); } 1830#endif 1831 1832#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1833 constexpr float 1834 tgamma(float __x) 1835 { return __builtin_tgammaf(__x); } 1836 1837 constexpr long double 1838 tgamma(long double __x) 1839 { return __builtin_tgammal(__x); } 1840#endif 1841 1842#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1843 template<typename _Tp> 1844 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1845 double>::__type 1846 tgamma(_Tp __x) 1847 { return __builtin_tgamma(__x); } 1848#endif 1849 1850#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1851 constexpr float 1852 trunc(float __x) 1853 { return __builtin_truncf(__x); } 1854 1855 constexpr long double 1856 trunc(long double __x) 1857 { return __builtin_truncl(__x); } 1858#endif 1859 1860#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1861 template<typename _Tp> 1862 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1863 double>::__type 1864 trunc(_Tp __x) 1865 { return __builtin_trunc(__x); } 1866#endif 1867 1868_GLIBCXX_END_NAMESPACE_VERSION 1869} // namespace 1870 1871#endif // _GLIBCXX_USE_C99_MATH_TR1 1872 1873#endif // C++11 1874 1875#endif 1876