visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Branch: main
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
toolchain-gcc-arm-embedded/arm-none-eabi/include/c++/10.2.1/cmath

1933 lines
48KB
Raw Permalink Blame History 

  1. // -*- C++ -*- C forwarding header.

  2. 

  3. // Copyright (C) 1997-2020 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. #if _GLIBCXX_USE_C99_MATH

  517. #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC

  518. 

  519. // These are possible macros imported from C99-land.

  520. #undef fpclassify

  521. #undef isfinite

  522. #undef isinf

  523. #undef isnan

  524. #undef isnormal

  525. #undef signbit

  526. #undef isgreater

  527. #undef isgreaterequal

  528. #undef isless

  529. #undef islessequal

  530. #undef islessgreater

  531. #undef isunordered

  532. 

  533. #if __cplusplus >= 201103L

  534. 

  535. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  536.   constexpr int

  537.   fpclassify(float __x)

  538.   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,

  539. 				FP_SUBNORMAL, FP_ZERO, __x); }

  540. 

  541.   constexpr int

  542.   fpclassify(double __x)

  543.   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,

  544. 				FP_SUBNORMAL, FP_ZERO, __x); }

  545. 

  546.   constexpr int

  547.   fpclassify(long double __x)

  548.   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,

  549. 				FP_SUBNORMAL, FP_ZERO, __x); }

  550. #endif

  551. 

  552. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  553.   template<typename _Tp>

  554.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,

  555.                                               int>::__type

  556.     fpclassify(_Tp __x)

  557.     { return __x != 0 ? FP_NORMAL : FP_ZERO; }

  558. #endif

  559. 

  560. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  561.   constexpr bool

  562.   isfinite(float __x)

  563.   { return __builtin_isfinite(__x); }

  564. 

  565.   constexpr bool

  566.   isfinite(double __x)

  567.   { return __builtin_isfinite(__x); }

  568. 

  569.   constexpr bool

  570.   isfinite(long double __x)

  571.   { return __builtin_isfinite(__x); }

  572. #endif

  573. 

  574. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  575.   template<typename _Tp>

  576.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,

  577.                                               bool>::__type

  578.     isfinite(_Tp __x)

  579.     { return true; }

  580. #endif

  581. 

  582. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  583.   constexpr bool

  584.   isinf(float __x)

  585.   { return __builtin_isinf(__x); }

  586. 

  587. #if _GLIBCXX_HAVE_OBSOLETE_ISINF \

  588.   && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC

  589.   using ::isinf;

  590. #else

  591.   constexpr bool

  592.   isinf(double __x)

  593.   { return __builtin_isinf(__x); }

  594. #endif

  595. 

  596.   constexpr bool

  597.   isinf(long double __x)

  598.   { return __builtin_isinf(__x); }

  599. #endif

  600. 

  601. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  602.   template<typename _Tp>

  603.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,

  604.                                               bool>::__type

  605.     isinf(_Tp __x)

  606.     { return false; }

  607. #endif

  608. 

  609. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  610.   constexpr bool

  611.   isnan(float __x)

  612.   { return __builtin_isnan(__x); }

  613. 

  614. #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \

  615.   && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC

  616.   using ::isnan;

  617. #else

  618.   constexpr bool

  619.   isnan(double __x)

  620.   { return __builtin_isnan(__x); }

  621. #endif

  622. 

  623.   constexpr bool

  624.   isnan(long double __x)

  625.   { return __builtin_isnan(__x); }

  626. #endif

  627. 

  628. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  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. #endif

  635. 

  636. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  637.   constexpr bool

  638.   isnormal(float __x)

  639.   { return __builtin_isnormal(__x); }

  640. 

  641.   constexpr bool

  642.   isnormal(double __x)

  643.   { return __builtin_isnormal(__x); }

  644. 

  645.   constexpr bool

  646.   isnormal(long double __x)

  647.   { return __builtin_isnormal(__x); }

  648. #endif

  649. 

  650. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  651.   template<typename _Tp>

  652.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,

  653.                                               bool>::__type

  654.     isnormal(_Tp __x)

  655.     { return __x != 0 ? true : false; }

  656. #endif

  657. 

  658. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  659.   // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.

  660.   constexpr bool

  661.   signbit(float __x)

  662.   { return __builtin_signbit(__x); }

  663. 

  664.   constexpr bool

  665.   signbit(double __x)

  666.   { return __builtin_signbit(__x); }

  667. 

  668.   constexpr bool

  669.   signbit(long double __x)

  670.   { return __builtin_signbit(__x); }

  671. #endif

  672. 

  673. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  674.   template<typename _Tp>

  675.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,

  676.                                               bool>::__type

  677.     signbit(_Tp __x)

  678.     { return __x < 0 ? true : false; }

  679. #endif

  680. 

  681. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  682.   constexpr bool

  683.   isgreater(float __x, float __y)

  684.   { return __builtin_isgreater(__x, __y); }

  685. 

  686.   constexpr bool

  687.   isgreater(double __x, double __y)

  688.   { return __builtin_isgreater(__x, __y); }

  689. 

  690.   constexpr bool

  691.   isgreater(long double __x, long double __y)

  692.   { return __builtin_isgreater(__x, __y); }

  693. #endif

  694. 

  695. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  696.   template<typename _Tp, typename _Up>

  697.     constexpr typename

  698.     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value

  699. 			    && __is_arithmetic<_Up>::__value), bool>::__type

  700.     isgreater(_Tp __x, _Up __y)

  701.     {

  702.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  703.       return __builtin_isgreater(__type(__x), __type(__y));

  704.     }

  705. #endif

  706. 

  707. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  708.   constexpr bool

  709.   isgreaterequal(float __x, float __y)

  710.   { return __builtin_isgreaterequal(__x, __y); }

  711. 

  712.   constexpr bool

  713.   isgreaterequal(double __x, double __y)

  714.   { return __builtin_isgreaterequal(__x, __y); }

  715. 

  716.   constexpr bool

  717.   isgreaterequal(long double __x, long double __y)

  718.   { return __builtin_isgreaterequal(__x, __y); }

  719. #endif

  720. 

  721. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  722.   template<typename _Tp, typename _Up>

  723.     constexpr typename

  724.     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value

  725. 			    && __is_arithmetic<_Up>::__value), bool>::__type

  726.     isgreaterequal(_Tp __x, _Up __y)

  727.     {

  728.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  729.       return __builtin_isgreaterequal(__type(__x), __type(__y));

  730.     }

  731. #endif

  732. 

  733. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  734.   constexpr bool

  735.   isless(float __x, float __y)

  736.   { return __builtin_isless(__x, __y); }

  737. 

  738.   constexpr bool

  739.   isless(double __x, double __y)

  740.   { return __builtin_isless(__x, __y); }

  741. 

  742.   constexpr bool

  743.   isless(long double __x, long double __y)

  744.   { return __builtin_isless(__x, __y); }

  745. #endif

  746. 

  747. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  748.   template<typename _Tp, typename _Up>

  749.     constexpr typename

  750.     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value

  751. 			    && __is_arithmetic<_Up>::__value), bool>::__type

  752.     isless(_Tp __x, _Up __y)

  753.     {

  754.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  755.       return __builtin_isless(__type(__x), __type(__y));

  756.     }

  757. #endif

  758. 

  759. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  760.   constexpr bool

  761.   islessequal(float __x, float __y)

  762.   { return __builtin_islessequal(__x, __y); }

  763. 

  764.   constexpr bool

  765.   islessequal(double __x, double __y)

  766.   { return __builtin_islessequal(__x, __y); }

  767. 

  768.   constexpr bool

  769.   islessequal(long double __x, long double __y)

  770.   { return __builtin_islessequal(__x, __y); }

  771. #endif

  772. 

  773. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  774.   template<typename _Tp, typename _Up>

  775.     constexpr typename

  776.     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value

  777. 			    && __is_arithmetic<_Up>::__value), bool>::__type

  778.     islessequal(_Tp __x, _Up __y)

  779.     {

  780.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  781.       return __builtin_islessequal(__type(__x), __type(__y));

  782.     }

  783. #endif

  784. 

  785. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  786.   constexpr bool

  787.   islessgreater(float __x, float __y)

  788.   { return __builtin_islessgreater(__x, __y); }

  789. 

  790.   constexpr bool

  791.   islessgreater(double __x, double __y)

  792.   { return __builtin_islessgreater(__x, __y); }

  793. 

  794.   constexpr bool

  795.   islessgreater(long double __x, long double __y)

  796.   { return __builtin_islessgreater(__x, __y); }

  797. #endif

  798. 

  799. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  800.   template<typename _Tp, typename _Up>

  801.     constexpr typename

  802.     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value

  803. 			    && __is_arithmetic<_Up>::__value), bool>::__type

  804.     islessgreater(_Tp __x, _Up __y)

  805.     {

  806.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  807.       return __builtin_islessgreater(__type(__x), __type(__y));

  808.     }

  809. #endif

  810. 

  811. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  812.   constexpr bool

  813.   isunordered(float __x, float __y)

  814.   { return __builtin_isunordered(__x, __y); }

  815. 

  816.   constexpr bool

  817.   isunordered(double __x, double __y)

  818.   { return __builtin_isunordered(__x, __y); }

  819. 

  820.   constexpr bool

  821.   isunordered(long double __x, long double __y)

  822.   { return __builtin_isunordered(__x, __y); }

  823. #endif

  824. 

  825. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  826.   template<typename _Tp, typename _Up>

  827.     constexpr typename

  828.     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value

  829. 			    && __is_arithmetic<_Up>::__value), bool>::__type

  830.     isunordered(_Tp __x, _Up __y)

  831.     {

  832.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  833.       return __builtin_isunordered(__type(__x), __type(__y));

  834.     }

  835. #endif

  836. 

  837. #else

  838. 

  839.   template<typename _Tp>

  840.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  841. 					   int>::__type

  842.     fpclassify(_Tp __f)

  843.     {

  844.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  845.       return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,

  846. 				  FP_SUBNORMAL, FP_ZERO, __type(__f));

  847.     }

  848. 

  849.   template<typename _Tp>

  850.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  851. 					   int>::__type

  852.     isfinite(_Tp __f)

  853.     {

  854.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  855.       return __builtin_isfinite(__type(__f));

  856.     }

  857. 

  858.   template<typename _Tp>

  859.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  860. 					   int>::__type

  861.     isinf(_Tp __f)

  862.     {

  863.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  864.       return __builtin_isinf(__type(__f));

  865.     }

  866. 

  867.   template<typename _Tp>

  868.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  869. 					   int>::__type

  870.     isnan(_Tp __f)

  871.     {

  872.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  873.       return __builtin_isnan(__type(__f));

  874.     }

  875. 

  876.   template<typename _Tp>

  877.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  878. 					   int>::__type

  879.     isnormal(_Tp __f)

  880.     {

  881.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  882.       return __builtin_isnormal(__type(__f));

  883.     }

  884. 

  885.   template<typename _Tp>

  886.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  887. 					   int>::__type

  888.     signbit(_Tp __f)

  889.     {

  890.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  891.       return __builtin_signbit(__type(__f));

  892.     }

  893. 

  894.   template<typename _Tp>

  895.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  896. 					   int>::__type

  897.     isgreater(_Tp __f1, _Tp __f2)

  898.     {

  899.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  900.       return __builtin_isgreater(__type(__f1), __type(__f2));

  901.     }

  902. 

  903.   template<typename _Tp>

  904.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  905. 					   int>::__type

  906.     isgreaterequal(_Tp __f1, _Tp __f2)

  907.     {

  908.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  909.       return __builtin_isgreaterequal(__type(__f1), __type(__f2));

  910.     }

  911. 

  912.   template<typename _Tp>

  913.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  914. 					   int>::__type

  915.     isless(_Tp __f1, _Tp __f2)

  916.     {

  917.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  918.       return __builtin_isless(__type(__f1), __type(__f2));

  919.     }

  920. 

  921.   template<typename _Tp>

  922.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  923. 					   int>::__type

  924.     islessequal(_Tp __f1, _Tp __f2)

  925.     {

  926.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  927.       return __builtin_islessequal(__type(__f1), __type(__f2));

  928.     }

  929. 

  930.   template<typename _Tp>

  931.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  932. 					   int>::__type

  933.     islessgreater(_Tp __f1, _Tp __f2)

  934.     {

  935.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  936.       return __builtin_islessgreater(__type(__f1), __type(__f2));

  937.     }

  938. 

  939.   template<typename _Tp>

  940.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,

  941. 					   int>::__type

  942.     isunordered(_Tp __f1, _Tp __f2)

  943.     {

  944.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  945.       return __builtin_isunordered(__type(__f1), __type(__f2));

  946.     }

  947. 

  948. #endif // C++11

  949. #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */

  950. #endif /* _GLIBCXX_USE_C99_MATH */

  951. 

  952. #if __cplusplus >= 201103L

  953. 

  954. #ifdef _GLIBCXX_USE_C99_MATH_TR1

  955. 

  956. #undef acosh

  957. #undef acoshf

  958. #undef acoshl

  959. #undef asinh

  960. #undef asinhf

  961. #undef asinhl

  962. #undef atanh

  963. #undef atanhf

  964. #undef atanhl

  965. #undef cbrt

  966. #undef cbrtf

  967. #undef cbrtl

  968. #undef copysign

  969. #undef copysignf

  970. #undef copysignl

  971. #undef erf

  972. #undef erff

  973. #undef erfl

  974. #undef erfc

  975. #undef erfcf

  976. #undef erfcl

  977. #undef exp2

  978. #undef exp2f

  979. #undef exp2l

  980. #undef expm1

  981. #undef expm1f

  982. #undef expm1l

  983. #undef fdim

  984. #undef fdimf

  985. #undef fdiml

  986. #undef fma

  987. #undef fmaf

  988. #undef fmal

  989. #undef fmax

  990. #undef fmaxf

  991. #undef fmaxl

  992. #undef fmin

  993. #undef fminf

  994. #undef fminl

  995. #undef hypot

  996. #undef hypotf

  997. #undef hypotl

  998. #undef ilogb

  999. #undef ilogbf

  1000. #undef ilogbl

  1001. #undef lgamma

  1002. #undef lgammaf

  1003. #undef lgammal

  1004. #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS

  1005. #undef llrint

  1006. #undef llrintf

  1007. #undef llrintl

  1008. #undef llround

  1009. #undef llroundf

  1010. #undef llroundl

  1011. #endif

  1012. #undef log1p

  1013. #undef log1pf

  1014. #undef log1pl

  1015. #undef log2

  1016. #undef log2f

  1017. #undef log2l

  1018. #undef logb

  1019. #undef logbf

  1020. #undef logbl

  1021. #undef lrint

  1022. #undef lrintf

  1023. #undef lrintl

  1024. #undef lround

  1025. #undef lroundf

  1026. #undef lroundl

  1027. #undef nan

  1028. #undef nanf

  1029. #undef nanl

  1030. #undef nearbyint

  1031. #undef nearbyintf

  1032. #undef nearbyintl

  1033. #undef nextafter

  1034. #undef nextafterf

  1035. #undef nextafterl

  1036. #undef nexttoward

  1037. #undef nexttowardf

  1038. #undef nexttowardl

  1039. #undef remainder

  1040. #undef remainderf

  1041. #undef remainderl

  1042. #undef remquo

  1043. #undef remquof

  1044. #undef remquol

  1045. #undef rint

  1046. #undef rintf

  1047. #undef rintl

  1048. #undef round

  1049. #undef roundf

  1050. #undef roundl

  1051. #undef scalbln

  1052. #undef scalblnf

  1053. #undef scalblnl

  1054. #undef scalbn

  1055. #undef scalbnf

  1056. #undef scalbnl

  1057. #undef tgamma

  1058. #undef tgammaf

  1059. #undef tgammal

  1060. #undef trunc

  1061. #undef truncf

  1062. #undef truncl

  1063. 

  1064.   // types

  1065.   using ::double_t;

  1066.   using ::float_t;

  1067. 

  1068.   // functions

  1069.   using ::acosh;

  1070.   using ::acoshf;

  1071.   using ::acoshl;

  1072. 

  1073.   using ::asinh;

  1074.   using ::asinhf;

  1075.   using ::asinhl;

  1076. 

  1077.   using ::atanh;

  1078.   using ::atanhf;

  1079.   using ::atanhl;

  1080. 

  1081.   using ::cbrt;

  1082.   using ::cbrtf;

  1083.   using ::cbrtl;

  1084. 

  1085.   using ::copysign;

  1086.   using ::copysignf;

  1087.   using ::copysignl;

  1088. 

  1089.   using ::erf;

  1090.   using ::erff;

  1091.   using ::erfl;

  1092. 

  1093.   using ::erfc;

  1094.   using ::erfcf;

  1095.   using ::erfcl;

  1096. 

  1097.   using ::exp2;

  1098.   using ::exp2f;

  1099.   using ::exp2l;

  1100. 

  1101.   using ::expm1;

  1102.   using ::expm1f;

  1103.   using ::expm1l;

  1104. 

  1105.   using ::fdim;

  1106.   using ::fdimf;

  1107.   using ::fdiml;

  1108. 

  1109.   using ::fma;

  1110.   using ::fmaf;

  1111.   using ::fmal;

  1112. 

  1113.   using ::fmax;

  1114.   using ::fmaxf;

  1115.   using ::fmaxl;

  1116. 

  1117.   using ::fmin;

  1118.   using ::fminf;

  1119.   using ::fminl;

  1120. 

  1121.   using ::hypot;

  1122.   using ::hypotf;

  1123.   using ::hypotl;

  1124. 

  1125.   using ::ilogb;

  1126.   using ::ilogbf;

  1127.   using ::ilogbl;

  1128. 

  1129.   using ::lgamma;

  1130.   using ::lgammaf;

  1131.   using ::lgammal;

  1132. 

  1133. #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS

  1134.   using ::llrint;

  1135.   using ::llrintf;

  1136.   using ::llrintl;

  1137. 

  1138.   using ::llround;

  1139.   using ::llroundf;

  1140.   using ::llroundl;

  1141. #endif

  1142. 

  1143.   using ::log1p;

  1144.   using ::log1pf;

  1145.   using ::log1pl;

  1146. 

  1147.   using ::log2;

  1148.   using ::log2f;

  1149.   using ::log2l;

  1150. 

  1151.   using ::logb;

  1152.   using ::logbf;

  1153.   using ::logbl;

  1154. 

  1155.   using ::lrint;

  1156.   using ::lrintf;

  1157.   using ::lrintl;

  1158. 

  1159.   using ::lround;

  1160.   using ::lroundf;

  1161.   using ::lroundl;

  1162. 

  1163.   using ::nan;

  1164.   using ::nanf;

  1165.   using ::nanl;

  1166. 

  1167.   using ::nearbyint;

  1168.   using ::nearbyintf;

  1169.   using ::nearbyintl;

  1170. 

  1171.   using ::nextafter;

  1172.   using ::nextafterf;

  1173.   using ::nextafterl;

  1174. 

  1175.   using ::nexttoward;

  1176.   using ::nexttowardf;

  1177.   using ::nexttowardl;

  1178. 

  1179.   using ::remainder;

  1180.   using ::remainderf;

  1181.   using ::remainderl;

  1182. 

  1183.   using ::remquo;

  1184.   using ::remquof;

  1185.   using ::remquol;

  1186. 

  1187.   using ::rint;

  1188.   using ::rintf;

  1189.   using ::rintl;

  1190. 

  1191.   using ::round;

  1192.   using ::roundf;

  1193.   using ::roundl;

  1194. 

  1195.   using ::scalbln;

  1196.   using ::scalblnf;

  1197.   using ::scalblnl;

  1198. 

  1199.   using ::scalbn;

  1200.   using ::scalbnf;

  1201.   using ::scalbnl;

  1202. 

  1203.   using ::tgamma;

  1204.   using ::tgammaf;

  1205.   using ::tgammal;

  1206. 

  1207.   using ::trunc;

  1208.   using ::truncf;

  1209.   using ::truncl;

  1210. 

  1211.   /// Additional overloads.

  1212. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1213.   constexpr float

  1214.   acosh(float __x)

  1215.   { return __builtin_acoshf(__x); }

  1216. 

  1217.   constexpr long double

  1218.   acosh(long double __x)

  1219.   { return __builtin_acoshl(__x); }

  1220. #endif

  1221. 

  1222. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1223.   template<typename _Tp>

  1224.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1225.                                               double>::__type

  1226.     acosh(_Tp __x)

  1227.     { return __builtin_acosh(__x); }

  1228. #endif

  1229. 

  1230. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1231.   constexpr float

  1232.   asinh(float __x)

  1233.   { return __builtin_asinhf(__x); }

  1234. 

  1235.   constexpr long double

  1236.   asinh(long double __x)

  1237.   { return __builtin_asinhl(__x); }

  1238. #endif

  1239. 

  1240. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1241.   template<typename _Tp>

  1242.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1243.                                               double>::__type

  1244.     asinh(_Tp __x)

  1245.     { return __builtin_asinh(__x); }

  1246. #endif

  1247. 

  1248. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1249.   constexpr float

  1250.   atanh(float __x)

  1251.   { return __builtin_atanhf(__x); }

  1252. 

  1253.   constexpr long double

  1254.   atanh(long double __x)

  1255.   { return __builtin_atanhl(__x); }

  1256. #endif

  1257. 

  1258. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1259.   template<typename _Tp>

  1260.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1261.                                               double>::__type

  1262.     atanh(_Tp __x)

  1263.     { return __builtin_atanh(__x); }

  1264. #endif

  1265. 

  1266. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1267.   constexpr float

  1268.   cbrt(float __x)

  1269.   { return __builtin_cbrtf(__x); }

  1270. 

  1271.   constexpr long double

  1272.   cbrt(long double __x)

  1273.   { return __builtin_cbrtl(__x); }

  1274. #endif

  1275. 

  1276. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1277.   template<typename _Tp>

  1278.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1279.                                               double>::__type

  1280.     cbrt(_Tp __x)

  1281.     { return __builtin_cbrt(__x); }

  1282. #endif

  1283. 

  1284. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1285.   constexpr float

  1286.   copysign(float __x, float __y)

  1287.   { return __builtin_copysignf(__x, __y); }

  1288. 

  1289.   constexpr long double

  1290.   copysign(long double __x, long double __y)

  1291.   { return __builtin_copysignl(__x, __y); }

  1292. #endif

  1293. 

  1294. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1295.   template<typename _Tp, typename _Up>

  1296.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1297.     copysign(_Tp __x, _Up __y)

  1298.     {

  1299.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1300.       return copysign(__type(__x), __type(__y));

  1301.     }

  1302. #endif

  1303. 

  1304. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1305.   constexpr float

  1306.   erf(float __x)

  1307.   { return __builtin_erff(__x); }

  1308. 

  1309.   constexpr long double

  1310.   erf(long double __x)

  1311.   { return __builtin_erfl(__x); }

  1312. #endif

  1313. 

  1314. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1315.   template<typename _Tp>

  1316.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1317.                                               double>::__type

  1318.     erf(_Tp __x)

  1319.     { return __builtin_erf(__x); }

  1320. #endif

  1321. 

  1322. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1323.   constexpr float

  1324.   erfc(float __x)

  1325.   { return __builtin_erfcf(__x); }

  1326. 

  1327.   constexpr long double

  1328.   erfc(long double __x)

  1329.   { return __builtin_erfcl(__x); }

  1330. #endif

  1331. 

  1332. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1333.   template<typename _Tp>

  1334.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1335.                                               double>::__type

  1336.     erfc(_Tp __x)

  1337.     { return __builtin_erfc(__x); }

  1338. #endif

  1339. 

  1340. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1341.   constexpr float

  1342.   exp2(float __x)

  1343.   { return __builtin_exp2f(__x); }

  1344. 

  1345.   constexpr long double

  1346.   exp2(long double __x)

  1347.   { return __builtin_exp2l(__x); }

  1348. #endif

  1349. 

  1350. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1351.   template<typename _Tp>

  1352.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1353.                                               double>::__type

  1354.     exp2(_Tp __x)

  1355.     { return __builtin_exp2(__x); }

  1356. #endif

  1357. 

  1358. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1359.   constexpr float

  1360.   expm1(float __x)

  1361.   { return __builtin_expm1f(__x); }

  1362. 

  1363.   constexpr long double

  1364.   expm1(long double __x)

  1365.   { return __builtin_expm1l(__x); }

  1366. #endif

  1367. 

  1368. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1369.   template<typename _Tp>

  1370.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1371.                                               double>::__type

  1372.     expm1(_Tp __x)

  1373.     { return __builtin_expm1(__x); }

  1374. #endif

  1375. 

  1376. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1377.   constexpr float

  1378.   fdim(float __x, float __y)

  1379.   { return __builtin_fdimf(__x, __y); }

  1380. 

  1381.   constexpr long double

  1382.   fdim(long double __x, long double __y)

  1383.   { return __builtin_fdiml(__x, __y); }

  1384. #endif

  1385. 

  1386. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1387.   template<typename _Tp, typename _Up>

  1388.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1389.     fdim(_Tp __x, _Up __y)

  1390.     {

  1391.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1392.       return fdim(__type(__x), __type(__y));

  1393.     }

  1394. #endif

  1395. 

  1396. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1397.   constexpr float

  1398.   fma(float __x, float __y, float __z)

  1399.   { return __builtin_fmaf(__x, __y, __z); }

  1400. 

  1401.   constexpr long double

  1402.   fma(long double __x, long double __y, long double __z)

  1403.   { return __builtin_fmal(__x, __y, __z); }

  1404. #endif

  1405. 

  1406. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1407.   template<typename _Tp, typename _Up, typename _Vp>

  1408.     constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type

  1409.     fma(_Tp __x, _Up __y, _Vp __z)

  1410.     {

  1411.       typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;

  1412.       return fma(__type(__x), __type(__y), __type(__z));

  1413.     }

  1414. #endif

  1415. 

  1416. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1417.   constexpr float

  1418.   fmax(float __x, float __y)

  1419.   { return __builtin_fmaxf(__x, __y); }

  1420. 

  1421.   constexpr long double

  1422.   fmax(long double __x, long double __y)

  1423.   { return __builtin_fmaxl(__x, __y); }

  1424. #endif

  1425. 

  1426. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1427.   template<typename _Tp, typename _Up>

  1428.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1429.     fmax(_Tp __x, _Up __y)

  1430.     {

  1431.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1432.       return fmax(__type(__x), __type(__y));

  1433.     }

  1434. #endif

  1435. 

  1436. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1437.   constexpr float

  1438.   fmin(float __x, float __y)

  1439.   { return __builtin_fminf(__x, __y); }

  1440. 

  1441.   constexpr long double

  1442.   fmin(long double __x, long double __y)

  1443.   { return __builtin_fminl(__x, __y); }

  1444. #endif

  1445. 

  1446. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1447.   template<typename _Tp, typename _Up>

  1448.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1449.     fmin(_Tp __x, _Up __y)

  1450.     {

  1451.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1452.       return fmin(__type(__x), __type(__y));

  1453.     }

  1454. #endif

  1455. 

  1456. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1457.   constexpr float

  1458.   hypot(float __x, float __y)

  1459.   { return __builtin_hypotf(__x, __y); }

  1460. 

  1461.   constexpr long double

  1462.   hypot(long double __x, long double __y)

  1463.   { return __builtin_hypotl(__x, __y); }

  1464. #endif

  1465. 

  1466. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1467.   template<typename _Tp, typename _Up>

  1468.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1469.     hypot(_Tp __x, _Up __y)

  1470.     {

  1471.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1472.       return hypot(__type(__x), __type(__y));

  1473.     }

  1474. #endif

  1475. 

  1476. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1477.   constexpr int

  1478.   ilogb(float __x)

  1479.   { return __builtin_ilogbf(__x); }

  1480. 

  1481.   constexpr int

  1482.   ilogb(long double __x)

  1483.   { return __builtin_ilogbl(__x); }

  1484. #endif

  1485. 

  1486. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1487.   template<typename _Tp>

  1488.     constexpr

  1489.     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1490.                                     int>::__type

  1491.     ilogb(_Tp __x)

  1492.     { return __builtin_ilogb(__x); }

  1493. #endif

  1494. 

  1495. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1496.   constexpr float

  1497.   lgamma(float __x)

  1498.   { return __builtin_lgammaf(__x); }

  1499. 

  1500.   constexpr long double

  1501.   lgamma(long double __x)

  1502.   { return __builtin_lgammal(__x); }

  1503. #endif

  1504. 

  1505. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1506.   template<typename _Tp>

  1507.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1508.                                               double>::__type

  1509.     lgamma(_Tp __x)

  1510.     { return __builtin_lgamma(__x); }

  1511. #endif

  1512. 

  1513. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1514.   constexpr long long

  1515.   llrint(float __x)

  1516.   { return __builtin_llrintf(__x); }

  1517. 

  1518.   constexpr long long

  1519.   llrint(long double __x)

  1520.   { return __builtin_llrintl(__x); }

  1521. #endif

  1522. 

  1523. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1524.   template<typename _Tp>

  1525.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1526.                                               long long>::__type

  1527.     llrint(_Tp __x)

  1528.     { return __builtin_llrint(__x); }

  1529. #endif

  1530. 

  1531. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1532.   constexpr long long

  1533.   llround(float __x)

  1534.   { return __builtin_llroundf(__x); }

  1535. 

  1536.   constexpr long long

  1537.   llround(long double __x)

  1538.   { return __builtin_llroundl(__x); }

  1539. #endif

  1540. 

  1541. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1542.   template<typename _Tp>

  1543.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1544.                                               long long>::__type

  1545.     llround(_Tp __x)

  1546.     { return __builtin_llround(__x); }

  1547. #endif

  1548. 

  1549. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1550.   constexpr float

  1551.   log1p(float __x)

  1552.   { return __builtin_log1pf(__x); }

  1553. 

  1554.   constexpr long double

  1555.   log1p(long double __x)

  1556.   { return __builtin_log1pl(__x); }

  1557. #endif

  1558. 

  1559. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1560.   template<typename _Tp>

  1561.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1562.                                               double>::__type

  1563.     log1p(_Tp __x)

  1564.     { return __builtin_log1p(__x); }

  1565. #endif

  1566. 

  1567. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1568.   // DR 568.

  1569.   constexpr float

  1570.   log2(float __x)

  1571.   { return __builtin_log2f(__x); }

  1572. 

  1573.   constexpr long double

  1574.   log2(long double __x)

  1575.   { return __builtin_log2l(__x); }

  1576. #endif

  1577. 

  1578. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1579.   template<typename _Tp>

  1580.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1581.                                               double>::__type

  1582.     log2(_Tp __x)

  1583.     { return __builtin_log2(__x); }

  1584. #endif

  1585. 

  1586. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1587.   constexpr float

  1588.   logb(float __x)

  1589.   { return __builtin_logbf(__x); }

  1590. 

  1591.   constexpr long double

  1592.   logb(long double __x)

  1593.   { return __builtin_logbl(__x); }

  1594. #endif

  1595. 

  1596. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1597.   template<typename _Tp>

  1598.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1599.                                               double>::__type

  1600.     logb(_Tp __x)

  1601.     { return __builtin_logb(__x); }

  1602. #endif

  1603. 

  1604. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1605.   constexpr long

  1606.   lrint(float __x)

  1607.   { return __builtin_lrintf(__x); }

  1608. 

  1609.   constexpr long

  1610.   lrint(long double __x)

  1611.   { return __builtin_lrintl(__x); }

  1612. #endif

  1613. 

  1614. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1615.   template<typename _Tp>

  1616.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1617.                                               long>::__type

  1618.     lrint(_Tp __x)

  1619.     { return __builtin_lrint(__x); }

  1620. #endif

  1621. 

  1622. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1623.   constexpr long

  1624.   lround(float __x)

  1625.   { return __builtin_lroundf(__x); }

  1626. 

  1627.   constexpr long

  1628.   lround(long double __x)

  1629.   { return __builtin_lroundl(__x); }

  1630. #endif

  1631. 

  1632. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1633.   template<typename _Tp>

  1634.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1635.                                               long>::__type

  1636.     lround(_Tp __x)

  1637.     { return __builtin_lround(__x); }

  1638. #endif

  1639. 

  1640. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1641.   constexpr float

  1642.   nearbyint(float __x)

  1643.   { return __builtin_nearbyintf(__x); }

  1644. 

  1645.   constexpr long double

  1646.   nearbyint(long double __x)

  1647.   { return __builtin_nearbyintl(__x); }

  1648. #endif

  1649. 

  1650. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1651.   template<typename _Tp>

  1652.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1653.                                               double>::__type

  1654.     nearbyint(_Tp __x)

  1655.     { return __builtin_nearbyint(__x); }

  1656. #endif

  1657. 

  1658. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1659.   constexpr float

  1660.   nextafter(float __x, float __y)

  1661.   { return __builtin_nextafterf(__x, __y); }

  1662. 

  1663.   constexpr long double

  1664.   nextafter(long double __x, long double __y)

  1665.   { return __builtin_nextafterl(__x, __y); }

  1666. #endif

  1667. 

  1668. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1669.   template<typename _Tp, typename _Up>

  1670.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1671.     nextafter(_Tp __x, _Up __y)

  1672.     {

  1673.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1674.       return nextafter(__type(__x), __type(__y));

  1675.     }

  1676. #endif

  1677. 

  1678. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1679.   constexpr float

  1680.   nexttoward(float __x, long double __y)

  1681.   { return __builtin_nexttowardf(__x, __y); }

  1682. 

  1683.   constexpr long double

  1684.   nexttoward(long double __x, long double __y)

  1685.   { return __builtin_nexttowardl(__x, __y); }

  1686. #endif

  1687. 

  1688. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1689.   template<typename _Tp>

  1690.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1691.                                               double>::__type

  1692.     nexttoward(_Tp __x, long double __y)

  1693.     { return __builtin_nexttoward(__x, __y); }

  1694. #endif

  1695. 

  1696. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1697.   constexpr float

  1698.   remainder(float __x, float __y)

  1699.   { return __builtin_remainderf(__x, __y); }

  1700. 

  1701.   constexpr long double

  1702.   remainder(long double __x, long double __y)

  1703.   { return __builtin_remainderl(__x, __y); }

  1704. #endif

  1705. 

  1706. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1707.   template<typename _Tp, typename _Up>

  1708.     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1709.     remainder(_Tp __x, _Up __y)

  1710.     {

  1711.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1712.       return remainder(__type(__x), __type(__y));

  1713.     }

  1714. #endif

  1715. 

  1716. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1717.   inline float

  1718.   remquo(float __x, float __y, int* __pquo)

  1719.   { return __builtin_remquof(__x, __y, __pquo); }

  1720. 

  1721.   inline long double

  1722.   remquo(long double __x, long double __y, int* __pquo)

  1723.   { return __builtin_remquol(__x, __y, __pquo); }

  1724. #endif

  1725. 

  1726. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1727.   template<typename _Tp, typename _Up>

  1728.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type

  1729.     remquo(_Tp __x, _Up __y, int* __pquo)

  1730.     {

  1731.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  1732.       return remquo(__type(__x), __type(__y), __pquo);

  1733.     }

  1734. #endif

  1735. 

  1736. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1737.   constexpr float

  1738.   rint(float __x)

  1739.   { return __builtin_rintf(__x); }

  1740. 

  1741.   constexpr long double

  1742.   rint(long double __x)

  1743.   { return __builtin_rintl(__x); }

  1744. #endif

  1745. 

  1746. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1747.   template<typename _Tp>

  1748.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1749.                                               double>::__type

  1750.     rint(_Tp __x)

  1751.     { return __builtin_rint(__x); }

  1752. #endif

  1753. 

  1754. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1755.   constexpr float

  1756.   round(float __x)

  1757.   { return __builtin_roundf(__x); }

  1758. 

  1759.   constexpr long double

  1760.   round(long double __x)

  1761.   { return __builtin_roundl(__x); }

  1762. #endif

  1763. 

  1764. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1765.   template<typename _Tp>

  1766.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1767.                                               double>::__type

  1768.     round(_Tp __x)

  1769.     { return __builtin_round(__x); }

  1770. #endif

  1771. 

  1772. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1773.   constexpr float

  1774.   scalbln(float __x, long __ex)

  1775.   { return __builtin_scalblnf(__x, __ex); }

  1776. 

  1777.   constexpr long double

  1778.   scalbln(long double __x, long __ex)

  1779.   { return __builtin_scalblnl(__x, __ex); }

  1780. #endif

  1781. 

  1782. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1783.   template<typename _Tp>

  1784.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1785.                                               double>::__type

  1786.     scalbln(_Tp __x, long __ex)

  1787.     { return __builtin_scalbln(__x, __ex); }

  1788. #endif

  1789.  

  1790. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1791.   constexpr float

  1792.   scalbn(float __x, int __ex)

  1793.   { return __builtin_scalbnf(__x, __ex); }

  1794. 

  1795.   constexpr long double

  1796.   scalbn(long double __x, int __ex)

  1797.   { return __builtin_scalbnl(__x, __ex); }

  1798. #endif

  1799. 

  1800. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1801.   template<typename _Tp>

  1802.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1803.                                               double>::__type

  1804.     scalbn(_Tp __x, int __ex)

  1805.     { return __builtin_scalbn(__x, __ex); }

  1806. #endif

  1807. 

  1808. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1809.   constexpr float

  1810.   tgamma(float __x)

  1811.   { return __builtin_tgammaf(__x); }

  1812. 

  1813.   constexpr long double

  1814.   tgamma(long double __x)

  1815.   { return __builtin_tgammal(__x); }

  1816. #endif

  1817. 

  1818. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1819.   template<typename _Tp>

  1820.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1821.                                               double>::__type

  1822.     tgamma(_Tp __x)

  1823.     { return __builtin_tgamma(__x); }

  1824. #endif

  1825.  

  1826. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP

  1827.   constexpr float

  1828.   trunc(float __x)

  1829.   { return __builtin_truncf(__x); }

  1830. 

  1831.   constexpr long double

  1832.   trunc(long double __x)

  1833.   { return __builtin_truncl(__x); }

  1834. #endif

  1835. 

  1836. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT

  1837.   template<typename _Tp>

  1838.     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 

  1839.                                               double>::__type

  1840.     trunc(_Tp __x)

  1841.     { return __builtin_trunc(__x); }

  1842. #endif

  1843. 

  1844. #endif // _GLIBCXX_USE_C99_MATH_TR1

  1845. #endif // C++11

  1846. 

  1847. #if __cplusplus > 201402L

  1848. 

  1849.   // [c.math.hypot3], three-dimensional hypotenuse

  1850. #define __cpp_lib_hypot 201603

  1851. 

  1852.   template<typename _Tp>

  1853.     inline _Tp

  1854.     __hypot3(_Tp __x, _Tp __y, _Tp __z)

  1855.     {

  1856.       __x = std::abs(__x);

  1857.       __y = std::abs(__y);

  1858.       __z = std::abs(__z);

  1859.       if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)

  1860. 	return __a * std::sqrt((__x / __a) * (__x / __a)

  1861. 			       + (__y / __a) * (__y / __a)

  1862. 			       + (__z / __a) * (__z / __a));

  1863.       else

  1864. 	return {};

  1865.     }

  1866. 

  1867.   inline float

  1868.   hypot(float __x, float __y, float __z)

  1869.   { return std::__hypot3<float>(__x, __y, __z); }

  1870. 

  1871.   inline double

  1872.   hypot(double __x, double __y, double __z)

  1873.   { return std::__hypot3<double>(__x, __y, __z); }

  1874. 

  1875.   inline long double

  1876.   hypot(long double __x, long double __y, long double __z)

  1877.   { return std::__hypot3<long double>(__x, __y, __z); }

  1878. 

  1879.   template<typename _Tp, typename _Up, typename _Vp>

  1880.     typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type

  1881.     hypot(_Tp __x, _Up __y, _Vp __z)

  1882.     {

  1883.       using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;

  1884.       return std::__hypot3<__type>(__x, __y, __z);

  1885.     }

  1886. #endif // C++17

  1887. 

  1888. #if __cplusplus > 201703L

  1889.   // linear interpolation

  1890. # define __cpp_lib_interpolate 201902L

  1891. 

  1892.   template<typename _Fp>

  1893.     constexpr _Fp

  1894.     __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept

  1895.     {

  1896.       if (__a <= 0 && __b >= 0 || __a >= 0 && __b <= 0)

  1897. 	return __t * __b + (1 - __t) * __a;

  1898. 

  1899.       if (__t == 1)

  1900. 	return __b;                        // exact

  1901. 

  1902.       // Exact at __t=0, monotonic except near __t=1,

  1903.       // bounded, determinate, and consistent:

  1904.       const _Fp __x = __a + __t * (__b - __a);

  1905.       return __t > 1 == __b > __a

  1906. 	? (__b < __x ? __x : __b)

  1907. 	: (__b > __x ? __x : __b);  // monotonic near __t=1

  1908.     }

  1909. 

  1910.   constexpr float

  1911.   lerp(float __a, float __b, float __t) noexcept

  1912.   { return std::__lerp(__a, __b, __t); }

  1913. 

  1914.   constexpr double

  1915.   lerp(double __a, double __b, double __t) noexcept

  1916.   { return std::__lerp(__a, __b, __t); }

  1917. 

  1918.   constexpr long double

  1919.   lerp(long double __a, long double __b, long double __t) noexcept

  1920.   { return std::__lerp(__a, __b, __t); }

  1921. #endif // C++20

  1922. 

  1923. _GLIBCXX_END_NAMESPACE_VERSION

  1924. } // namespace

  1925. 

  1926. #if _GLIBCXX_USE_STD_SPEC_FUNCS

  1927. #  include <bits/specfun.h>

  1928. #endif

  1929. 

  1930. } // extern "C++"

  1931. 

  1932. #endif