libstdc++
tr1/cmath
Go to the documentation of this file.
1 // TR1 cmath -*- C++ -*-
2 
3 // Copyright (C) 2006-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 tr1/cmath
26  * This is a TR1 C++ Library header.
27  */
28 
29 #ifndef _GLIBCXX_TR1_CMATH
30 #define _GLIBCXX_TR1_CMATH 1
31 
32 #pragma GCC system_header
33 
34 #include <cmath>
35 
36 #ifdef _GLIBCXX_USE_C99_MATH_TR1
37 
38 #undef acosh
39 #undef acoshf
40 #undef acoshl
41 #undef asinh
42 #undef asinhf
43 #undef asinhl
44 #undef atanh
45 #undef atanhf
46 #undef atanhl
47 #undef cbrt
48 #undef cbrtf
49 #undef cbrtl
50 #undef copysign
51 #undef copysignf
52 #undef copysignl
53 #undef erf
54 #undef erff
55 #undef erfl
56 #undef erfc
57 #undef erfcf
58 #undef erfcl
59 #undef exp2
60 #undef exp2f
61 #undef exp2l
62 #undef expm1
63 #undef expm1f
64 #undef expm1l
65 #undef fdim
66 #undef fdimf
67 #undef fdiml
68 #undef fma
69 #undef fmaf
70 #undef fmal
71 #undef fmax
72 #undef fmaxf
73 #undef fmaxl
74 #undef fmin
75 #undef fminf
76 #undef fminl
77 #undef hypot
78 #undef hypotf
79 #undef hypotl
80 #undef ilogb
81 #undef ilogbf
82 #undef ilogbl
83 #undef lgamma
84 #undef lgammaf
85 #undef lgammal
86 #undef llrint
87 #undef llrintf
88 #undef llrintl
89 #undef llround
90 #undef llroundf
91 #undef llroundl
92 #undef log1p
93 #undef log1pf
94 #undef log1pl
95 #undef log2
96 #undef log2f
97 #undef log2l
98 #undef logb
99 #undef logbf
100 #undef logbl
101 #undef lrint
102 #undef lrintf
103 #undef lrintl
104 #undef lround
105 #undef lroundf
106 #undef lroundl
107 #undef nan
108 #undef nanf
109 #undef nanl
110 #undef nearbyint
111 #undef nearbyintf
112 #undef nearbyintl
113 #undef nextafter
114 #undef nextafterf
115 #undef nextafterl
116 #undef nexttoward
117 #undef nexttowardf
118 #undef nexttowardl
119 #undef remainder
120 #undef remainderf
121 #undef remainderl
122 #undef remquo
123 #undef remquof
124 #undef remquol
125 #undef rint
126 #undef rintf
127 #undef rintl
128 #undef round
129 #undef roundf
130 #undef roundl
131 #undef scalbln
132 #undef scalblnf
133 #undef scalblnl
134 #undef scalbn
135 #undef scalbnf
136 #undef scalbnl
137 #undef tgamma
138 #undef tgammaf
139 #undef tgammal
140 #undef trunc
141 #undef truncf
142 #undef truncl
143 
144 #endif
145 
146 namespace std _GLIBCXX_VISIBILITY(default)
147 {
148 _GLIBCXX_BEGIN_NAMESPACE_VERSION
149 
150 namespace tr1
151 {
152 #if _GLIBCXX_USE_C99_MATH_TR1
153 
154  // Using declarations to bring names from libc's <math.h> into std::tr1.
155 
156  // types
157  using ::double_t;
158  using ::float_t;
159 
160  // functions
161  using ::acosh;
162  using ::acoshf;
163  using ::acoshl;
164 
165  using ::asinh;
166  using ::asinhf;
167  using ::asinhl;
168 
169  using ::atanh;
170  using ::atanhf;
171  using ::atanhl;
172 
173  using ::cbrt;
174  using ::cbrtf;
175  using ::cbrtl;
176 
177  using ::copysign;
178  using ::copysignf;
179  using ::copysignl;
180 
181  using ::erf;
182  using ::erff;
183  using ::erfl;
184 
185  using ::erfc;
186  using ::erfcf;
187  using ::erfcl;
188 
189  using ::exp2;
190  using ::exp2f;
191  using ::exp2l;
192 
193  using ::expm1;
194  using ::expm1f;
195  using ::expm1l;
196 
197  using ::fdim;
198  using ::fdimf;
199  using ::fdiml;
200 
201  using ::fma;
202  using ::fmaf;
203  using ::fmal;
204 
205  using ::fmax;
206  using ::fmaxf;
207  using ::fmaxl;
208 
209  using ::fmin;
210  using ::fminf;
211  using ::fminl;
212 
213  using ::hypot;
214  using ::hypotf;
215  using ::hypotl;
216 
217  using ::ilogb;
218  using ::ilogbf;
219  using ::ilogbl;
220 
221  using ::lgamma;
222  using ::lgammaf;
223  using ::lgammal;
224 
225  using ::llrint;
226  using ::llrintf;
227  using ::llrintl;
228 
229  using ::llround;
230  using ::llroundf;
231  using ::llroundl;
232 
233  using ::log1p;
234  using ::log1pf;
235  using ::log1pl;
236 
237  using ::log2;
238  using ::log2f;
239  using ::log2l;
240 
241  using ::logb;
242  using ::logbf;
243  using ::logbl;
244 
245  using ::lrint;
246  using ::lrintf;
247  using ::lrintl;
248 
249  using ::lround;
250  using ::lroundf;
251  using ::lroundl;
252 
253  using ::nan;
254  using ::nanf;
255  using ::nanl;
256 
257  using ::nearbyint;
258  using ::nearbyintf;
259  using ::nearbyintl;
260 
261  using ::nextafter;
262  using ::nextafterf;
263  using ::nextafterl;
264 
265  using ::nexttoward;
266  using ::nexttowardf;
267  using ::nexttowardl;
268 
269  using ::remainder;
270  using ::remainderf;
271  using ::remainderl;
272 
273  using ::remquo;
274  using ::remquof;
275  using ::remquol;
276 
277  using ::rint;
278  using ::rintf;
279  using ::rintl;
280 
281  using ::round;
282  using ::roundf;
283  using ::roundl;
284 
285  using ::scalbln;
286  using ::scalblnf;
287  using ::scalblnl;
288 
289  using ::scalbn;
290  using ::scalbnf;
291  using ::scalbnl;
292 
293  using ::tgamma;
294  using ::tgammaf;
295  using ::tgammal;
296 
297  using ::trunc;
298  using ::truncf;
299  using ::truncl;
300 
301 #endif
302 
303 #if _GLIBCXX_USE_C99_MATH
304 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
305 
306  /// Function template definitions [8.16.3].
307  template<typename _Tp>
308  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
309  int>::__type
310  fpclassify(_Tp __f)
311  {
312  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
313  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
314  FP_SUBNORMAL, FP_ZERO, __type(__f));
315  }
316 
317  template<typename _Tp>
318  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
319  int>::__type
320  isfinite(_Tp __f)
321  {
322  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
323  return __builtin_isfinite(__type(__f));
324  }
325 
326  template<typename _Tp>
327  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
328  int>::__type
329  isinf(_Tp __f)
330  {
331  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
332  return __builtin_isinf(__type(__f));
333  }
334 
335  template<typename _Tp>
336  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
337  int>::__type
338  isnan(_Tp __f)
339  {
340  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
341  return __builtin_isnan(__type(__f));
342  }
343 
344  template<typename _Tp>
345  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
346  int>::__type
347  isnormal(_Tp __f)
348  {
349  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
350  return __builtin_isnormal(__type(__f));
351  }
352 
353  template<typename _Tp>
354  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
355  int>::__type
356  signbit(_Tp __f)
357  {
358  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
359  return __builtin_signbit(__type(__f));
360  }
361 
362  template<typename _Tp>
363  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
364  int>::__type
365  isgreater(_Tp __f1, _Tp __f2)
366  {
367  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
368  return __builtin_isgreater(__type(__f1), __type(__f2));
369  }
370 
371  template<typename _Tp>
372  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
373  int>::__type
374  isgreaterequal(_Tp __f1, _Tp __f2)
375  {
376  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
377  return __builtin_isgreaterequal(__type(__f1), __type(__f2));
378  }
379 
380  template<typename _Tp>
381  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
382  int>::__type
383  isless(_Tp __f1, _Tp __f2)
384  {
385  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
386  return __builtin_isless(__type(__f1), __type(__f2));
387  }
388 
389  template<typename _Tp>
390  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
391  int>::__type
392  islessequal(_Tp __f1, _Tp __f2)
393  {
394  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
395  return __builtin_islessequal(__type(__f1), __type(__f2));
396  }
397 
398  template<typename _Tp>
399  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
400  int>::__type
401  islessgreater(_Tp __f1, _Tp __f2)
402  {
403  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
404  return __builtin_islessgreater(__type(__f1), __type(__f2));
405  }
406 
407  template<typename _Tp>
408  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
409  int>::__type
410  isunordered(_Tp __f1, _Tp __f2)
411  {
412  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
413  return __builtin_isunordered(__type(__f1), __type(__f2));
414  }
415 
416 #endif
417 #endif
418 
419 #if _GLIBCXX_USE_C99_MATH_TR1
420 
421  /** Additional overloads [8.16.4].
422  * @{
423  */
424 
425  // For functions defined in C++03 the additional overloads are already
426  // declared in <cmath> so we can just re-declare them in std::tr1.
427 
428  using std::acos;
429  using std::asin;
430  using std::atan;
431  using std::atan2;
432  using std::ceil;
433  using std::cos;
434  using std::cosh;
435  using std::exp;
436  using std::floor;
437  using std::fmod;
438  using std::frexp;
439  using std::ldexp;
440  using std::log;
441  using std::log10;
442  using std::sin;
443  using std::sinh;
444  using std::sqrt;
445  using std::tan;
446  using std::tanh;
447 
448 #if __cplusplus >= 201103L
449 
450  // Since C++11, <cmath> defines additional overloads for these functions
451  // in namespace std.
452 
453  using std::acosh;
454  using std::asinh;
455  using std::atanh;
456  using std::cbrt;
457  using std::copysign;
458  using std::erf;
459  using std::erfc;
460  using std::exp2;
461  using std::expm1;
462  using std::fdim;
463  using std::fma;
464  using std::fmax;
465  using std::fmin;
466  using std::hypot;
467  using std::ilogb;
468  using std::lgamma;
469  using std::llrint;
470  using std::llround;
471  using std::log1p;
472  using std::log2;
473  using std::logb;
474  using std::lrint;
475  using std::lround;
476  using std::nan;
477  using std::nearbyint;
478  using std::nextafter;
479  using std::nexttoward;
480  using std::remainder;
481  using std::remquo;
482  using std::rint;
483  using std::round;
484  using std::scalbln;
485  using std::scalbn;
486  using std::tgamma;
487  using std::trunc;
488 
489 #else // __cplusplus < 201103L
490 
491  // In C++03 we need to provide the additional overloads.
492 
493 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
494  inline float
495  acosh(float __x)
496  { return __builtin_acoshf(__x); }
497 
498  inline long double
499  acosh(long double __x)
500  { return __builtin_acoshl(__x); }
501 #endif
502 
503  template<typename _Tp>
504  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
505  double>::__type
506  acosh(_Tp __x)
507  { return __builtin_acosh(__x); }
508 
509 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
510  inline float
511  asinh(float __x)
512  { return __builtin_asinhf(__x); }
513 
514  inline long double
515  asinh(long double __x)
516  { return __builtin_asinhl(__x); }
517 #endif
518 
519  template<typename _Tp>
520  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
521  double>::__type
522  asinh(_Tp __x)
523  { return __builtin_asinh(__x); }
524 
525 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
526  inline float
527  atanh(float __x)
528  { return __builtin_atanhf(__x); }
529 
530  inline long double
531  atanh(long double __x)
532  { return __builtin_atanhl(__x); }
533 #endif
534 
535  template<typename _Tp>
536  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
537  double>::__type
538  atanh(_Tp __x)
539  { return __builtin_atanh(__x); }
540 
541 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
542  inline float
543  cbrt(float __x)
544  { return __builtin_cbrtf(__x); }
545 
546  inline long double
547  cbrt(long double __x)
548  { return __builtin_cbrtl(__x); }
549 #endif
550 
551  template<typename _Tp>
552  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
553  double>::__type
554  cbrt(_Tp __x)
555  { return __builtin_cbrt(__x); }
556 
557 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
558  inline float
559  copysign(float __x, float __y)
560  { return __builtin_copysignf(__x, __y); }
561 
562  inline long double
563  copysign(long double __x, long double __y)
564  { return __builtin_copysignl(__x, __y); }
565 #endif
566 
567  template<typename _Tp, typename _Up>
568  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
569  copysign(_Tp __x, _Up __y)
570  {
571  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
572  return copysign(__type(__x), __type(__y));
573  }
574 
575 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
576  inline float
577  erf(float __x)
578  { return __builtin_erff(__x); }
579 
580  inline long double
581  erf(long double __x)
582  { return __builtin_erfl(__x); }
583 #endif
584 
585  template<typename _Tp>
586  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
587  double>::__type
588  erf(_Tp __x)
589  { return __builtin_erf(__x); }
590 
591 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
592  inline float
593  erfc(float __x)
594  { return __builtin_erfcf(__x); }
595 
596  inline long double
597  erfc(long double __x)
598  { return __builtin_erfcl(__x); }
599 #endif
600 
601  template<typename _Tp>
602  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
603  double>::__type
604  erfc(_Tp __x)
605  { return __builtin_erfc(__x); }
606 
607 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
608  inline float
609  exp2(float __x)
610  { return __builtin_exp2f(__x); }
611 
612  inline long double
613  exp2(long double __x)
614  { return __builtin_exp2l(__x); }
615 #endif
616 
617  template<typename _Tp>
618  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
619  double>::__type
620  exp2(_Tp __x)
621  { return __builtin_exp2(__x); }
622 
623 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
624  inline float
625  expm1(float __x)
626  { return __builtin_expm1f(__x); }
627 
628  inline long double
629  expm1(long double __x)
630  { return __builtin_expm1l(__x); }
631 #endif
632 
633  template<typename _Tp>
634  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
635  double>::__type
636  expm1(_Tp __x)
637  { return __builtin_expm1(__x); }
638 
639 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
640  inline float
641  fdim(float __x, float __y)
642  { return __builtin_fdimf(__x, __y); }
643 
644  inline long double
645  fdim(long double __x, long double __y)
646  { return __builtin_fdiml(__x, __y); }
647 #endif
648 
649  template<typename _Tp, typename _Up>
650  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
651  fdim(_Tp __x, _Up __y)
652  {
653  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
654  return fdim(__type(__x), __type(__y));
655  }
656 
657 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
658  inline float
659  fma(float __x, float __y, float __z)
660  { return __builtin_fmaf(__x, __y, __z); }
661 
662  inline long double
663  fma(long double __x, long double __y, long double __z)
664  { return __builtin_fmal(__x, __y, __z); }
665 #endif
666 
667  template<typename _Tp, typename _Up, typename _Vp>
668  inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
669  fma(_Tp __x, _Up __y, _Vp __z)
670  {
671  typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
672  return fma(__type(__x), __type(__y), __type(__z));
673  }
674 
675 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
676  inline float
677  fmax(float __x, float __y)
678  { return __builtin_fmaxf(__x, __y); }
679 
680  inline long double
681  fmax(long double __x, long double __y)
682  { return __builtin_fmaxl(__x, __y); }
683 #endif
684 
685  template<typename _Tp, typename _Up>
686  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
687  fmax(_Tp __x, _Up __y)
688  {
689  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
690  return fmax(__type(__x), __type(__y));
691  }
692 
693 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
694  inline float
695  fmin(float __x, float __y)
696  { return __builtin_fminf(__x, __y); }
697 
698  inline long double
699  fmin(long double __x, long double __y)
700  { return __builtin_fminl(__x, __y); }
701 #endif
702 
703  template<typename _Tp, typename _Up>
704  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
705  fmin(_Tp __x, _Up __y)
706  {
707  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
708  return fmin(__type(__x), __type(__y));
709  }
710 
711 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
712  inline float
713  hypot(float __x, float __y)
714  { return __builtin_hypotf(__x, __y); }
715 
716  inline long double
717  hypot(long double __x, long double __y)
718  { return __builtin_hypotl(__x, __y); }
719 #endif
720 
721  template<typename _Tp, typename _Up>
722  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
723  hypot(_Tp __y, _Up __x)
724  {
725  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
726  return hypot(__type(__y), __type(__x));
727  }
728 
729 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
730  inline int
731  ilogb(float __x)
732  { return __builtin_ilogbf(__x); }
733 
734  inline int
735  ilogb(long double __x)
736  { return __builtin_ilogbl(__x); }
737 #endif
738 
739  template<typename _Tp>
740  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
741  int>::__type
742  ilogb(_Tp __x)
743  { return __builtin_ilogb(__x); }
744 
745 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
746  inline float
747  lgamma(float __x)
748  { return __builtin_lgammaf(__x); }
749 
750  inline long double
751  lgamma(long double __x)
752  { return __builtin_lgammal(__x); }
753 #endif
754 
755  template<typename _Tp>
756  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
757  double>::__type
758  lgamma(_Tp __x)
759  { return __builtin_lgamma(__x); }
760 
761 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
762  inline long long
763  llrint(float __x)
764  { return __builtin_llrintf(__x); }
765 
766  inline long long
767  llrint(long double __x)
768  { return __builtin_llrintl(__x); }
769 #endif
770 
771  template<typename _Tp>
772  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
773  long long>::__type
774  llrint(_Tp __x)
775  { return __builtin_llrint(__x); }
776 
777 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
778  inline long long
779  llround(float __x)
780  { return __builtin_llroundf(__x); }
781 
782  inline long long
783  llround(long double __x)
784  { return __builtin_llroundl(__x); }
785 #endif
786 
787  template<typename _Tp>
788  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
789  long long>::__type
790  llround(_Tp __x)
791  { return __builtin_llround(__x); }
792 
793 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
794  inline float
795  log1p(float __x)
796  { return __builtin_log1pf(__x); }
797 
798  inline long double
799  log1p(long double __x)
800  { return __builtin_log1pl(__x); }
801 #endif
802 
803  template<typename _Tp>
804  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
805  double>::__type
806  log1p(_Tp __x)
807  { return __builtin_log1p(__x); }
808 
809  // DR 568.
810 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
811  inline float
812  log2(float __x)
813  { return __builtin_log2f(__x); }
814 
815  inline long double
816  log2(long double __x)
817  { return __builtin_log2l(__x); }
818 #endif
819 
820  template<typename _Tp>
821  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
822  double>::__type
823  log2(_Tp __x)
824  { return __builtin_log2(__x); }
825 
826 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
827  inline float
828  logb(float __x)
829  { return __builtin_logbf(__x); }
830 
831  inline long double
832  logb(long double __x)
833  { return __builtin_logbl(__x); }
834 #endif
835 
836  template<typename _Tp>
837  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
838  double>::__type
839  logb(_Tp __x)
840  {
841  return __builtin_logb(__x);
842  }
843 
844 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
845  inline long
846  lrint(float __x)
847  { return __builtin_lrintf(__x); }
848 
849  inline long
850  lrint(long double __x)
851  { return __builtin_lrintl(__x); }
852 #endif
853 
854  template<typename _Tp>
855  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
856  long>::__type
857  lrint(_Tp __x)
858  { return __builtin_lrint(__x); }
859 
860 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
861  inline long
862  lround(float __x)
863  { return __builtin_lroundf(__x); }
864 
865  inline long
866  lround(long double __x)
867  { return __builtin_lroundl(__x); }
868 #endif
869 
870  template<typename _Tp>
871  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
872  long>::__type
873  lround(_Tp __x)
874  { return __builtin_lround(__x); }
875 
876 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
877  inline float
878  nearbyint(float __x)
879  { return __builtin_nearbyintf(__x); }
880 
881  inline long double
882  nearbyint(long double __x)
883  { return __builtin_nearbyintl(__x); }
884 #endif
885 
886  template<typename _Tp>
887  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
888  double>::__type
889  nearbyint(_Tp __x)
890  { return __builtin_nearbyint(__x); }
891 
892 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
893  inline float
894  nextafter(float __x, float __y)
895  { return __builtin_nextafterf(__x, __y); }
896 
897  inline long double
898  nextafter(long double __x, long double __y)
899  { return __builtin_nextafterl(__x, __y); }
900 #endif
901 
902  template<typename _Tp, typename _Up>
903  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
904  nextafter(_Tp __x, _Up __y)
905  {
906  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
907  return nextafter(__type(__x), __type(__y));
908  }
909 
910 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
911  inline float
912  nexttoward(float __x, long double __y)
913  { return __builtin_nexttowardf(__x, __y); }
914 
915  inline long double
916  nexttoward(long double __x, long double __y)
917  { return __builtin_nexttowardl(__x, __y); }
918 #endif
919 
920  template<typename _Tp>
921  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
922  double>::__type
923  nexttoward(_Tp __x, long double __y)
924  { return __builtin_nexttoward(__x, __y); }
925 
926 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
927  inline float
928  remainder(float __x, float __y)
929  { return __builtin_remainderf(__x, __y); }
930 
931  inline long double
932  remainder(long double __x, long double __y)
933  { return __builtin_remainderl(__x, __y); }
934 #endif
935 
936  template<typename _Tp, typename _Up>
937  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
938  remainder(_Tp __x, _Up __y)
939  {
940  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
941  return remainder(__type(__x), __type(__y));
942  }
943 
944 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
945  inline float
946  remquo(float __x, float __y, int* __pquo)
947  { return __builtin_remquof(__x, __y, __pquo); }
948 
949  inline long double
950  remquo(long double __x, long double __y, int* __pquo)
951  { return __builtin_remquol(__x, __y, __pquo); }
952 #endif
953 
954  template<typename _Tp, typename _Up>
955  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
956  remquo(_Tp __x, _Up __y, int* __pquo)
957  {
958  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
959  return remquo(__type(__x), __type(__y), __pquo);
960  }
961 
962 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
963  inline float
964  rint(float __x)
965  { return __builtin_rintf(__x); }
966 
967  inline long double
968  rint(long double __x)
969  { return __builtin_rintl(__x); }
970 #endif
971 
972  template<typename _Tp>
973  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
974  double>::__type
975  rint(_Tp __x)
976  { return __builtin_rint(__x); }
977 
978 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
979  inline float
980  round(float __x)
981  { return __builtin_roundf(__x); }
982 
983  inline long double
984  round(long double __x)
985  { return __builtin_roundl(__x); }
986 #endif
987 
988  template<typename _Tp>
989  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
990  double>::__type
991  round(_Tp __x)
992  { return __builtin_round(__x); }
993 
994 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
995  inline float
996  scalbln(float __x, long __ex)
997  { return __builtin_scalblnf(__x, __ex); }
998 
999  inline long double
1000  scalbln(long double __x, long __ex)
1001  { return __builtin_scalblnl(__x, __ex); }
1002 #endif
1003 
1004  template<typename _Tp>
1005  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1006  double>::__type
1007  scalbln(_Tp __x, long __ex)
1008  { return __builtin_scalbln(__x, __ex); }
1009 
1010 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1011  inline float
1012  scalbn(float __x, int __ex)
1013  { return __builtin_scalbnf(__x, __ex); }
1014 
1015  inline long double
1016  scalbn(long double __x, int __ex)
1017  { return __builtin_scalbnl(__x, __ex); }
1018 #endif
1019 
1020  template<typename _Tp>
1021  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1022  double>::__type
1023  scalbn(_Tp __x, int __ex)
1024  { return __builtin_scalbn(__x, __ex); }
1025 
1026 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1027  inline float
1028  tgamma(float __x)
1029  { return __builtin_tgammaf(__x); }
1030 
1031  inline long double
1032  tgamma(long double __x)
1033  { return __builtin_tgammal(__x); }
1034 #endif
1035 
1036  template<typename _Tp>
1037  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1038  double>::__type
1039  tgamma(_Tp __x)
1040  { return __builtin_tgamma(__x); }
1041 
1042 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1043  inline float
1044  trunc(float __x)
1045  { return __builtin_truncf(__x); }
1046 
1047  inline long double
1048  trunc(long double __x)
1049  { return __builtin_truncl(__x); }
1050 #endif
1051 
1052  template<typename _Tp>
1053  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1054  double>::__type
1055  trunc(_Tp __x)
1056  { return __builtin_trunc(__x); }
1057 
1058 #endif // __cplusplus < 201103L
1059 
1060  /// @}
1061 
1062 #endif /* _GLIBCXX_USE_C99_MATH_TR1 */
1063 
1064  // DR 550. What should the return type of pow(float,int) be?
1065  // NB: C++11 and TR1 != C++03.
1066 
1067  // We cannot do "using std::pow;" because that would bring in unwanted
1068  // pow(*, int) overloads in C++03, with the wrong return type. Instead we
1069  // define all the necessary overloads, but the std::tr1::pow(double, double)
1070  // overload cannot be provided here, because <tr1/math.h> would add it to
1071  // the global namespace where it would clash with ::pow(double,double) from
1072  // libc (revealed by the fix of PR c++/54537).
1073  // The solution is to forward std::tr1::pow(double,double) to
1074  // std::pow(double,double) via the function template below. See
1075  // the discussion about this issue here:
1076  // http://gcc.gnu.org/ml/gcc-patches/2012-09/msg01278.html
1077 
1078 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1079  inline float
1080  pow(float __x, float __y)
1081  { return std::pow(__x, __y); }
1082 
1083  inline long double
1084  pow(long double __x, long double __y)
1085  { return std::pow(__x, __y); }
1086 #endif
1087 
1088  template<typename _Tp, typename _Up>
1089  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1090  pow(_Tp __x, _Up __y)
1091  {
1092  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1093  return std::pow(__type(__x), __type(__y));
1094  }
1095 
1096 #if __cplusplus >= 201103L
1097  // We also deal with fabs in a special way, because "using std::fabs;"
1098  // could bring in C++11's std::fabs<T>(const std::complex<T>&) with a
1099  // different return type from std::tr1::fabs<T>(const std::complex<T>&).
1100  // We define the necessary overloads, except std::tr1::fabs(double) which
1101  // could clash with ::fabs(double) from libc.
1102  // The function template handles double as well as integers, forwarding
1103  // to std::fabs.
1104 
1105 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
1106 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1107  inline float
1108  fabs(float __x)
1109  { return __builtin_fabsf(__x); }
1110 
1111  inline long double
1112  fabs(long double __x)
1113  { return __builtin_fabsl(__x); }
1114 #endif
1115 #endif
1116 
1117  template<typename _Tp>
1118  inline typename __gnu_cxx::__promote<_Tp>::__type
1119  fabs(_Tp __x)
1120  { return std::fabs(__x); }
1121 
1122 #else // ! C++11
1123 
1124  // For C++03 just use std::fabs as there is no overload for std::complex<>.
1125  using std::fabs;
1126 
1127 #endif // C++11
1128 
1129 } // namespace tr1
1130 _GLIBCXX_END_NAMESPACE_VERSION
1131 } // namespace std
1132 
1133 /**
1134  * @defgroup tr1_math_spec_func TR1 Mathematical Special Functions
1135  * @ingroup numerics
1136  *
1137  * A collection of advanced mathematical special functions.
1138  */
1139 
1140 #if _GLIBCXX_USE_STD_SPEC_FUNCS
1141 
1142 namespace std _GLIBCXX_VISIBILITY(default)
1143 {
1144 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1145 
1146 namespace tr1
1147 {
1148  using std::assoc_laguerref;
1149  using std::assoc_laguerrel;
1150  using std::assoc_laguerre;
1151 
1152  using std::assoc_legendref;
1153  using std::assoc_legendrel;
1154  using std::assoc_legendre;
1155 
1156  using std::betaf;
1157  using std::betal;
1158  using std::beta;
1159 
1160  using std::comp_ellint_1f;
1161  using std::comp_ellint_1l;
1162  using std::comp_ellint_1;
1163 
1164  using std::comp_ellint_2f;
1165  using std::comp_ellint_2l;
1166  using std::comp_ellint_2;
1167 
1168  using std::comp_ellint_3f;
1169  using std::comp_ellint_3l;
1170  using std::comp_ellint_3;
1171 
1172  using std::cyl_bessel_if;
1173  using std::cyl_bessel_il;
1174  using std::cyl_bessel_i;
1175 
1176  using std::cyl_bessel_jf;
1177  using std::cyl_bessel_jl;
1178  using std::cyl_bessel_j;
1179 
1180  using std::cyl_bessel_kf;
1181  using std::cyl_bessel_kl;
1182  using std::cyl_bessel_k;
1183 
1184  using std::cyl_neumannf;
1185  using std::cyl_neumannl;
1186  using std::cyl_neumann;
1187 
1188  using std::ellint_1f;
1189  using std::ellint_1l;
1190  using std::ellint_1;
1191 
1192  using std::ellint_2f;
1193  using std::ellint_2l;
1194  using std::ellint_2;
1195 
1196  using std::ellint_3f;
1197  using std::ellint_3l;
1198  using std::ellint_3;
1199 
1200  using std::expintf;
1201  using std::expintl;
1202  using std::expint;
1203 
1204  using std::hermitef;
1205  using std::hermitel;
1206  using std::hermite;
1207 
1208  using std::laguerref;
1209  using std::laguerrel;
1210  using std::laguerre;
1211 
1212  using std::legendref;
1213  using std::legendrel;
1214  using std::legendre;
1215 
1216  using std::riemann_zetaf;
1217  using std::riemann_zetal;
1218  using std::riemann_zeta;
1219 
1220  using std::sph_besself;
1221  using std::sph_bessell;
1222  using std::sph_bessel;
1223 
1224  using std::sph_legendref;
1225  using std::sph_legendrel;
1226  using std::sph_legendre;
1227 
1228  using std::sph_neumannf;
1229  using std::sph_neumannl;
1230  using std::sph_neumann;
1231 
1232 } // namespace tr1
1233 _GLIBCXX_END_NAMESPACE_VERSION
1234 } // namespace std
1235 
1236 #else // ! _GLIBCXX_USE_STD_SPEC_FUNCS
1237 
1238 #include <bits/stl_algobase.h>
1239 #include <limits>
1240 #include <tr1/type_traits>
1241 
1242 #include <tr1/gamma.tcc>
1243 #include <tr1/bessel_function.tcc>
1244 #include <tr1/beta_function.tcc>
1245 #include <tr1/ell_integral.tcc>
1246 #include <tr1/exp_integral.tcc>
1247 #include <tr1/legendre_function.tcc>
1248 #include <tr1/modified_bessel_func.tcc>
1249 #include <tr1/poly_hermite.tcc>
1250 #include <tr1/poly_laguerre.tcc>
1251 #include <tr1/riemann_zeta.tcc>
1252 
1253 namespace std _GLIBCXX_VISIBILITY(default)
1254 {
1255 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1256 namespace tr1
1257  {
1258  /** @addtogroup tr1_math_spec_func
1259  * @{
1260  */
1261 
1262  inline float
1263  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
1264  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
1265 
1266  inline long double
1267  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
1268  {
1269  return __detail::__assoc_laguerre<long double>(__n, __m, __x);
1270  }
1271 
1272  /// 5.2.1.1 Associated Laguerre polynomials.
1273  template<typename _Tp>
1274  inline typename __gnu_cxx::__promote<_Tp>::__type
1275  assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
1276  {
1277  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1278  return __detail::__assoc_laguerre<__type>(__n, __m, __x);
1279  }
1280 
1281  inline float
1282  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
1283  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
1284 
1285  inline long double
1286  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
1287  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
1288 
1289  /// 5.2.1.2 Associated Legendre functions.
1290  template<typename _Tp>
1291  inline typename __gnu_cxx::__promote<_Tp>::__type
1292  assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
1293  {
1294  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1295  return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
1296  }
1297 
1298  inline float
1299  betaf(float __x, float __y)
1300  { return __detail::__beta<float>(__x, __y); }
1301 
1302  inline long double
1303  betal(long double __x, long double __y)
1304  { return __detail::__beta<long double>(__x, __y); }
1305 
1306  /// 5.2.1.3 Beta functions.
1307  template<typename _Tpx, typename _Tpy>
1308  inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
1309  beta(_Tpx __x, _Tpy __y)
1310  {
1311  typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
1312  return __detail::__beta<__type>(__x, __y);
1313  }
1314 
1315  inline float
1316  comp_ellint_1f(float __k)
1317  { return __detail::__comp_ellint_1<float>(__k); }
1318 
1319  inline long double
1320  comp_ellint_1l(long double __k)
1321  { return __detail::__comp_ellint_1<long double>(__k); }
1322 
1323  /// 5.2.1.4 Complete elliptic integrals of the first kind.
1324  template<typename _Tp>
1325  inline typename __gnu_cxx::__promote<_Tp>::__type
1326  comp_ellint_1(_Tp __k)
1327  {
1328  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1329  return __detail::__comp_ellint_1<__type>(__k);
1330  }
1331 
1332  inline float
1333  comp_ellint_2f(float __k)
1334  { return __detail::__comp_ellint_2<float>(__k); }
1335 
1336  inline long double
1337  comp_ellint_2l(long double __k)
1338  { return __detail::__comp_ellint_2<long double>(__k); }
1339 
1340  /// 5.2.1.5 Complete elliptic integrals of the second kind.
1341  template<typename _Tp>
1342  inline typename __gnu_cxx::__promote<_Tp>::__type
1343  comp_ellint_2(_Tp __k)
1344  {
1345  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1346  return __detail::__comp_ellint_2<__type>(__k);
1347  }
1348 
1349  inline float
1350  comp_ellint_3f(float __k, float __nu)
1351  { return __detail::__comp_ellint_3<float>(__k, __nu); }
1352 
1353  inline long double
1354  comp_ellint_3l(long double __k, long double __nu)
1355  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
1356 
1357  /// 5.2.1.6 Complete elliptic integrals of the third kind.
1358  template<typename _Tp, typename _Tpn>
1359  inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
1360  comp_ellint_3(_Tp __k, _Tpn __nu)
1361  {
1362  typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
1363  return __detail::__comp_ellint_3<__type>(__k, __nu);
1364  }
1365 
1366  inline float
1367  cyl_bessel_if(float __nu, float __x)
1368  { return __detail::__cyl_bessel_i<float>(__nu, __x); }
1369 
1370  inline long double
1371  cyl_bessel_il(long double __nu, long double __x)
1372  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
1373 
1374  /// 5.2.1.8 Regular modified cylindrical Bessel functions.
1375  template<typename _Tpnu, typename _Tp>
1376  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1377  cyl_bessel_i(_Tpnu __nu, _Tp __x)
1378  {
1379  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1380  return __detail::__cyl_bessel_i<__type>(__nu, __x);
1381  }
1382 
1383  inline float
1384  cyl_bessel_jf(float __nu, float __x)
1385  { return __detail::__cyl_bessel_j<float>(__nu, __x); }
1386 
1387  inline long double
1388  cyl_bessel_jl(long double __nu, long double __x)
1389  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
1390 
1391  /// 5.2.1.9 Cylindrical Bessel functions (of the first kind).
1392  template<typename _Tpnu, typename _Tp>
1393  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1394  cyl_bessel_j(_Tpnu __nu, _Tp __x)
1395  {
1396  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1397  return __detail::__cyl_bessel_j<__type>(__nu, __x);
1398  }
1399 
1400  inline float
1401  cyl_bessel_kf(float __nu, float __x)
1402  { return __detail::__cyl_bessel_k<float>(__nu, __x); }
1403 
1404  inline long double
1405  cyl_bessel_kl(long double __nu, long double __x)
1406  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
1407 
1408  /// 5.2.1.10 Irregular modified cylindrical Bessel functions.
1409  template<typename _Tpnu, typename _Tp>
1410  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1411  cyl_bessel_k(_Tpnu __nu, _Tp __x)
1412  {
1413  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1414  return __detail::__cyl_bessel_k<__type>(__nu, __x);
1415  }
1416 
1417  inline float
1418  cyl_neumannf(float __nu, float __x)
1419  { return __detail::__cyl_neumann_n<float>(__nu, __x); }
1420 
1421  inline long double
1422  cyl_neumannl(long double __nu, long double __x)
1423  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
1424 
1425  /// 5.2.1.11 Cylindrical Neumann functions.
1426  template<typename _Tpnu, typename _Tp>
1427  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1428  cyl_neumann(_Tpnu __nu, _Tp __x)
1429  {
1430  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1431  return __detail::__cyl_neumann_n<__type>(__nu, __x);
1432  }
1433 
1434  inline float
1435  ellint_1f(float __k, float __phi)
1436  { return __detail::__ellint_1<float>(__k, __phi); }
1437 
1438  inline long double
1439  ellint_1l(long double __k, long double __phi)
1440  { return __detail::__ellint_1<long double>(__k, __phi); }
1441 
1442  /// 5.2.1.12 Incomplete elliptic integrals of the first kind.
1443  template<typename _Tp, typename _Tpp>
1444  inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
1445  ellint_1(_Tp __k, _Tpp __phi)
1446  {
1447  typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
1448  return __detail::__ellint_1<__type>(__k, __phi);
1449  }
1450 
1451  inline float
1452  ellint_2f(float __k, float __phi)
1453  { return __detail::__ellint_2<float>(__k, __phi); }
1454 
1455  inline long double
1456  ellint_2l(long double __k, long double __phi)
1457  { return __detail::__ellint_2<long double>(__k, __phi); }
1458 
1459  /// 5.2.1.13 Incomplete elliptic integrals of the second kind.
1460  template<typename _Tp, typename _Tpp>
1461  inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
1462  ellint_2(_Tp __k, _Tpp __phi)
1463  {
1464  typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
1465  return __detail::__ellint_2<__type>(__k, __phi);
1466  }
1467 
1468  inline float
1469  ellint_3f(float __k, float __nu, float __phi)
1470  { return __detail::__ellint_3<float>(__k, __nu, __phi); }
1471 
1472  inline long double
1473  ellint_3l(long double __k, long double __nu, long double __phi)
1474  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
1475 
1476  /// 5.2.1.14 Incomplete elliptic integrals of the third kind.
1477  template<typename _Tp, typename _Tpn, typename _Tpp>
1478  inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
1479  ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
1480  {
1481  typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
1482  return __detail::__ellint_3<__type>(__k, __nu, __phi);
1483  }
1484 
1485  inline float
1486  expintf(float __x)
1487  { return __detail::__expint<float>(__x); }
1488 
1489  inline long double
1490  expintl(long double __x)
1491  { return __detail::__expint<long double>(__x); }
1492 
1493  /// 5.2.1.15 Exponential integrals.
1494  template<typename _Tp>
1495  inline typename __gnu_cxx::__promote<_Tp>::__type
1496  expint(_Tp __x)
1497  {
1498  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1499  return __detail::__expint<__type>(__x);
1500  }
1501 
1502  inline float
1503  hermitef(unsigned int __n, float __x)
1504  { return __detail::__poly_hermite<float>(__n, __x); }
1505 
1506  inline long double
1507  hermitel(unsigned int __n, long double __x)
1508  { return __detail::__poly_hermite<long double>(__n, __x); }
1509 
1510  /// 5.2.1.16 Hermite polynomials.
1511  template<typename _Tp>
1512  inline typename __gnu_cxx::__promote<_Tp>::__type
1513  hermite(unsigned int __n, _Tp __x)
1514  {
1515  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1516  return __detail::__poly_hermite<__type>(__n, __x);
1517  }
1518 
1519  inline float
1520  laguerref(unsigned int __n, float __x)
1521  { return __detail::__laguerre<float>(__n, __x); }
1522 
1523  inline long double
1524  laguerrel(unsigned int __n, long double __x)
1525  { return __detail::__laguerre<long double>(__n, __x); }
1526 
1527  /// 5.2.1.18 Laguerre polynomials.
1528  template<typename _Tp>
1529  inline typename __gnu_cxx::__promote<_Tp>::__type
1530  laguerre(unsigned int __n, _Tp __x)
1531  {
1532  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1533  return __detail::__laguerre<__type>(__n, __x);
1534  }
1535 
1536  inline float
1537  legendref(unsigned int __n, float __x)
1538  { return __detail::__poly_legendre_p<float>(__n, __x); }
1539 
1540  inline long double
1541  legendrel(unsigned int __n, long double __x)
1542  { return __detail::__poly_legendre_p<long double>(__n, __x); }
1543 
1544  /// 5.2.1.19 Legendre polynomials.
1545  template<typename _Tp>
1546  inline typename __gnu_cxx::__promote<_Tp>::__type
1547  legendre(unsigned int __n, _Tp __x)
1548  {
1549  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1550  return __detail::__poly_legendre_p<__type>(__n, __x);
1551  }
1552 
1553  inline float
1554  riemann_zetaf(float __x)
1555  { return __detail::__riemann_zeta<float>(__x); }
1556 
1557  inline long double
1558  riemann_zetal(long double __x)
1559  { return __detail::__riemann_zeta<long double>(__x); }
1560 
1561  /// 5.2.1.20 Riemann zeta function.
1562  template<typename _Tp>
1563  inline typename __gnu_cxx::__promote<_Tp>::__type
1564  riemann_zeta(_Tp __x)
1565  {
1566  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1567  return __detail::__riemann_zeta<__type>(__x);
1568  }
1569 
1570  inline float
1571  sph_besself(unsigned int __n, float __x)
1572  { return __detail::__sph_bessel<float>(__n, __x); }
1573 
1574  inline long double
1575  sph_bessell(unsigned int __n, long double __x)
1576  { return __detail::__sph_bessel<long double>(__n, __x); }
1577 
1578  /// 5.2.1.21 Spherical Bessel functions.
1579  template<typename _Tp>
1580  inline typename __gnu_cxx::__promote<_Tp>::__type
1581  sph_bessel(unsigned int __n, _Tp __x)
1582  {
1583  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1584  return __detail::__sph_bessel<__type>(__n, __x);
1585  }
1586 
1587  inline float
1588  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
1589  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
1590 
1591  inline long double
1592  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
1593  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
1594 
1595  /// 5.2.1.22 Spherical associated Legendre functions.
1596  template<typename _Tp>
1597  inline typename __gnu_cxx::__promote<_Tp>::__type
1598  sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
1599  {
1600  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1601  return __detail::__sph_legendre<__type>(__l, __m, __theta);
1602  }
1603 
1604  inline float
1605  sph_neumannf(unsigned int __n, float __x)
1606  { return __detail::__sph_neumann<float>(__n, __x); }
1607 
1608  inline long double
1609  sph_neumannl(unsigned int __n, long double __x)
1610  { return __detail::__sph_neumann<long double>(__n, __x); }
1611 
1612  /// 5.2.1.23 Spherical Neumann functions.
1613  template<typename _Tp>
1614  inline typename __gnu_cxx::__promote<_Tp>::__type
1615  sph_neumann(unsigned int __n, _Tp __x)
1616  {
1617  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1618  return __detail::__sph_neumann<__type>(__n, __x);
1619  }
1620 
1621  /// @} tr1_math_spec_func
1622 
1623 } // namespace tr1
1624 
1625 _GLIBCXX_END_NAMESPACE_VERSION
1626 } // namespace std
1627 
1628 #endif // _GLIBCXX_USE_STD_SPEC_FUNCS
1629 
1630 #if _GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__)
1631 namespace std _GLIBCXX_VISIBILITY(default)
1632 {
1633 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1634 
1635 namespace tr1
1636 {
1637  using __gnu_cxx::conf_hypergf;
1638  using __gnu_cxx::conf_hypergl;
1639  using __gnu_cxx::conf_hyperg;
1640 
1641  using __gnu_cxx::hypergf;
1642  using __gnu_cxx::hypergl;
1643  using __gnu_cxx::hyperg;
1644 } // namespace tr1
1645 
1646 _GLIBCXX_END_NAMESPACE_VERSION
1647 } // namespace std
1648 
1649 #else // ! (_GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__))
1650 
1651 #include <bits/stl_algobase.h>
1652 #include <limits>
1653 #include <tr1/type_traits>
1654 
1655 #include <tr1/hypergeometric.tcc>
1656 
1657 namespace std _GLIBCXX_VISIBILITY(default)
1658 {
1659 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1660 
1661 namespace tr1
1662 {
1663  /** @addtogroup tr1_math_spec_func
1664  * @{
1665  */
1666 
1667  inline float
1668  conf_hypergf(float __a, float __c, float __x)
1669  { return __detail::__conf_hyperg<float>(__a, __c, __x); }
1670 
1671  inline long double
1672  conf_hypergl(long double __a, long double __c, long double __x)
1673  { return __detail::__conf_hyperg<long double>(__a, __c, __x); }
1674 
1675  /// 5.2.1.7 Confluent hypergeometric functions.
1676  template<typename _Tpa, typename _Tpc, typename _Tp>
1677  inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
1678  conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
1679  {
1680  typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
1681  return __detail::__conf_hyperg<__type>(__a, __c, __x);
1682  }
1683 
1684  inline float
1685  hypergf(float __a, float __b, float __c, float __x)
1686  { return __detail::__hyperg<float>(__a, __b, __c, __x); }
1687 
1688  inline long double
1689  hypergl(long double __a, long double __b, long double __c, long double __x)
1690  { return __detail::__hyperg<long double>(__a, __b, __c, __x); }
1691 
1692  /// 5.2.1.17 Hypergeometric functions.
1693  template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
1694  inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
1695  hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
1696  {
1697  typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
1698  return __detail::__hyperg<__type>(__a, __b, __c, __x);
1699  }
1700 
1701  /// @} tr1_math_spec_func
1702 
1703 } // namespace tr1
1704 
1705 _GLIBCXX_END_NAMESPACE_VERSION
1706 } // namespace std
1707 #endif // _GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__)
1708 
1709 #endif // _GLIBCXX_TR1_CMATH