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