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