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