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