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