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
148namespace std _GLIBCXX_VISIBILITY(default)
149{
150_GLIBCXX_BEGIN_NAMESPACE_VERSION
151
152namespace 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
1144namespace std _GLIBCXX_VISIBILITY(default)
1145{
1146_GLIBCXX_BEGIN_NAMESPACE_VERSION
1147
1148namespace 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
1255namespace std _GLIBCXX_VISIBILITY(default)
1256{
1257_GLIBCXX_BEGIN_NAMESPACE_VERSION
1258namespace 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__)
1633namespace std _GLIBCXX_VISIBILITY(default)
1634{
1635_GLIBCXX_BEGIN_NAMESPACE_VERSION
1636
1637namespace 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
1659namespace std _GLIBCXX_VISIBILITY(default)
1660{
1661_GLIBCXX_BEGIN_NAMESPACE_VERSION
1662
1663namespace 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