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