|  | @@ -1,1878 +0,0 @@
 | 
	
		
			
				|  |  | -diff -Nur gcc-4.8.3.orig/libstdc++-v3/include/c_global/cmath gcc-4.8.3/libstdc++-v3/include/c_global/cmath
 | 
	
		
			
				|  |  | ---- gcc-4.8.3.orig/libstdc++-v3/include/c_global/cmath	2013-02-03 18:54:05.000000000 +0100
 | 
	
		
			
				|  |  | -+++ gcc-4.8.3/libstdc++-v3/include/c_global/cmath	2014-07-27 07:24:43.600272987 +0200
 | 
	
		
			
				|  |  | -@@ -1040,143 +1040,213 @@
 | 
	
		
			
				|  |  | -   // functions
 | 
	
		
			
				|  |  | -   using ::acosh;
 | 
	
		
			
				|  |  | -   using ::acoshf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::acoshl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::asinh;
 | 
	
		
			
				|  |  | -   using ::asinhf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::asinhl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::atanh;
 | 
	
		
			
				|  |  | -   using ::atanhf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::atanhl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::cbrt;
 | 
	
		
			
				|  |  | -   using ::cbrtf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::cbrtl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::copysign;
 | 
	
		
			
				|  |  | -   using ::copysignf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::copysignl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::erf;
 | 
	
		
			
				|  |  | -   using ::erff;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::erfl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::erfc;
 | 
	
		
			
				|  |  | -   using ::erfcf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::erfcl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::exp2;
 | 
	
		
			
				|  |  | -   using ::exp2f;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::exp2l;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::expm1;
 | 
	
		
			
				|  |  | -   using ::expm1f;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::expm1l;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fdim;
 | 
	
		
			
				|  |  | -   using ::fdimf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fdiml;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fma;
 | 
	
		
			
				|  |  | -   using ::fmaf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fmal;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fmax;
 | 
	
		
			
				|  |  | -   using ::fmaxf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fmaxl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fmin;
 | 
	
		
			
				|  |  | -   using ::fminf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fminl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::hypot;
 | 
	
		
			
				|  |  | -   using ::hypotf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::hypotl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::ilogb;
 | 
	
		
			
				|  |  | -   using ::ilogbf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::ilogbl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::lgamma;
 | 
	
		
			
				|  |  | -   using ::lgammaf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::lgammal;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::llrint;
 | 
	
		
			
				|  |  | -   using ::llrintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::llrintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::llround;
 | 
	
		
			
				|  |  | -   using ::llroundf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::llroundl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::log1p;
 | 
	
		
			
				|  |  | -   using ::log1pf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::log1pl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::log2;
 | 
	
		
			
				|  |  | -   using ::log2f;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::log2l;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::logb;
 | 
	
		
			
				|  |  | -   using ::logbf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::logbl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::lrint;
 | 
	
		
			
				|  |  | -   using ::lrintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::lrintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::lround;
 | 
	
		
			
				|  |  | -   using ::lroundf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::lroundl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nan;
 | 
	
		
			
				|  |  | -   using ::nanf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nanl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nearbyint;
 | 
	
		
			
				|  |  | -   using ::nearbyintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nearbyintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nextafter;
 | 
	
		
			
				|  |  | -   using ::nextafterf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nextafterl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nexttoward;
 | 
	
		
			
				|  |  | -   using ::nexttowardf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nexttowardl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::remainder;
 | 
	
		
			
				|  |  | -   using ::remainderf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::remainderl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::remquo;
 | 
	
		
			
				|  |  | -   using ::remquof;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::remquol;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::rint;
 | 
	
		
			
				|  |  | -   using ::rintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::rintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::round;
 | 
	
		
			
				|  |  | -   using ::roundf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::roundl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::scalbln;
 | 
	
		
			
				|  |  | -   using ::scalblnf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::scalblnl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::scalbn;
 | 
	
		
			
				|  |  | -   using ::scalbnf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::scalbnl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::tgamma;
 | 
	
		
			
				|  |  | -   using ::tgammaf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::tgammal;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::trunc;
 | 
	
		
			
				|  |  | -   using ::truncf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::truncl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   /// Additional overloads.
 | 
	
		
			
				|  |  | -   constexpr float
 | 
	
		
			
				|  |  | -diff -Nur gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath gcc-4.8.3/libstdc++-v3/include/tr1/cmath
 | 
	
		
			
				|  |  | ---- gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath	2013-02-03 18:54:05.000000000 +0100
 | 
	
		
			
				|  |  | -+++ gcc-4.8.3/libstdc++-v3/include/tr1/cmath	2014-07-26 12:58:43.652151897 +0200
 | 
	
		
			
				|  |  | -@@ -158,143 +158,213 @@
 | 
	
		
			
				|  |  | -   // functions
 | 
	
		
			
				|  |  | -   using ::acosh;
 | 
	
		
			
				|  |  | -   using ::acoshf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::acoshl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::asinh;
 | 
	
		
			
				|  |  | -   using ::asinhf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::asinhl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::atanh;
 | 
	
		
			
				|  |  | -   using ::atanhf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::atanhl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::cbrt;
 | 
	
		
			
				|  |  | -   using ::cbrtf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::cbrtl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::copysign;
 | 
	
		
			
				|  |  | -   using ::copysignf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::copysignl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::erf;
 | 
	
		
			
				|  |  | -   using ::erff;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::erfl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::erfc;
 | 
	
		
			
				|  |  | -   using ::erfcf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::erfcl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::exp2;
 | 
	
		
			
				|  |  | -   using ::exp2f;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::exp2l;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::expm1;
 | 
	
		
			
				|  |  | -   using ::expm1f;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::expm1l;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fdim;
 | 
	
		
			
				|  |  | -   using ::fdimf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fdiml;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fma;
 | 
	
		
			
				|  |  | -   using ::fmaf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fmal;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fmax;
 | 
	
		
			
				|  |  | -   using ::fmaxf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fmaxl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::fmin;
 | 
	
		
			
				|  |  | -   using ::fminf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::fminl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::hypot;
 | 
	
		
			
				|  |  | -   using ::hypotf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::hypotl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::ilogb;
 | 
	
		
			
				|  |  | -   using ::ilogbf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::ilogbl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::lgamma;
 | 
	
		
			
				|  |  | -   using ::lgammaf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::lgammal;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::llrint;
 | 
	
		
			
				|  |  | -   using ::llrintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::llrintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::llround;
 | 
	
		
			
				|  |  | -   using ::llroundf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::llroundl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::log1p;
 | 
	
		
			
				|  |  | -   using ::log1pf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::log1pl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::log2;
 | 
	
		
			
				|  |  | -   using ::log2f;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::log2l;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::logb;
 | 
	
		
			
				|  |  | -   using ::logbf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::logbl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::lrint;
 | 
	
		
			
				|  |  | -   using ::lrintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::lrintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::lround;
 | 
	
		
			
				|  |  | -   using ::lroundf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::lroundl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nan;
 | 
	
		
			
				|  |  | -   using ::nanf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nanl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nearbyint;
 | 
	
		
			
				|  |  | -   using ::nearbyintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nearbyintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nextafter;
 | 
	
		
			
				|  |  | -   using ::nextafterf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nextafterl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::nexttoward;
 | 
	
		
			
				|  |  | -   using ::nexttowardf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::nexttowardl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::remainder;
 | 
	
		
			
				|  |  | -   using ::remainderf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::remainderl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::remquo;
 | 
	
		
			
				|  |  | -   using ::remquof;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::remquol;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::rint;
 | 
	
		
			
				|  |  | -   using ::rintf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::rintl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::round;
 | 
	
		
			
				|  |  | -   using ::roundf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::roundl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::scalbln;
 | 
	
		
			
				|  |  | -   using ::scalblnf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::scalblnl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::scalbn;
 | 
	
		
			
				|  |  | -   using ::scalbnf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::scalbnl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::tgamma;
 | 
	
		
			
				|  |  | -   using ::tgammaf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::tgammal;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -   using ::trunc;
 | 
	
		
			
				|  |  | -   using ::truncf;
 | 
	
		
			
				|  |  | -+#ifdef __LONG_DOUBLE_128__
 | 
	
		
			
				|  |  | -   using ::truncl;
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | - #endif
 | 
	
		
			
				|  |  | - 
 | 
	
		
			
				|  |  | -diff -Nur gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath.orig gcc-4.8.3/libstdc++-v3/include/tr1/cmath.orig
 | 
	
		
			
				|  |  | ---- gcc-4.8.3.orig/libstdc++-v3/include/tr1/cmath.orig	1970-01-01 01:00:00.000000000 +0100
 | 
	
		
			
				|  |  | -+++ gcc-4.8.3/libstdc++-v3/include/tr1/cmath.orig	2013-02-03 18:54:05.000000000 +0100
 | 
	
		
			
				|  |  | -@@ -0,0 +1,1440 @@
 | 
	
		
			
				|  |  | -+// TR1 cmath -*- C++ -*-
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+// Copyright (C) 2006-2013 Free Software Foundation, Inc.
 | 
	
		
			
				|  |  | -+//
 | 
	
		
			
				|  |  | -+// This file is part of the GNU ISO C++ Library.  This library is free
 | 
	
		
			
				|  |  | -+// software; you can redistribute it and/or modify it under the
 | 
	
		
			
				|  |  | -+// terms of the GNU General Public License as published by the
 | 
	
		
			
				|  |  | -+// Free Software Foundation; either version 3, or (at your option)
 | 
	
		
			
				|  |  | -+// any later version.
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+// This library is distributed in the hope that it will be useful,
 | 
	
		
			
				|  |  | -+// but WITHOUT ANY WARRANTY; without even the implied warranty of
 | 
	
		
			
				|  |  | -+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 | 
	
		
			
				|  |  | -+// GNU General Public License for more details.
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+// Under Section 7 of GPL version 3, you are granted additional
 | 
	
		
			
				|  |  | -+// permissions described in the GCC Runtime Library Exception, version
 | 
	
		
			
				|  |  | -+// 3.1, as published by the Free Software Foundation.
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+// You should have received a copy of the GNU General Public License and
 | 
	
		
			
				|  |  | -+// a copy of the GCC Runtime Library Exception along with this program;
 | 
	
		
			
				|  |  | -+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 | 
	
		
			
				|  |  | -+// <http://www.gnu.org/licenses/>.
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+/** @file tr1/cmath
 | 
	
		
			
				|  |  | -+ *  This is a TR1 C++ Library header. 
 | 
	
		
			
				|  |  | -+ */
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#ifndef _GLIBCXX_TR1_CMATH
 | 
	
		
			
				|  |  | -+#define _GLIBCXX_TR1_CMATH 1
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#pragma GCC system_header
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#include <cmath>
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#ifdef _GLIBCXX_USE_C99_MATH_TR1
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#undef acosh
 | 
	
		
			
				|  |  | -+#undef acoshf
 | 
	
		
			
				|  |  | -+#undef acoshl
 | 
	
		
			
				|  |  | -+#undef asinh
 | 
	
		
			
				|  |  | -+#undef asinhf
 | 
	
		
			
				|  |  | -+#undef asinhl
 | 
	
		
			
				|  |  | -+#undef atanh
 | 
	
		
			
				|  |  | -+#undef atanhf
 | 
	
		
			
				|  |  | -+#undef atanhl
 | 
	
		
			
				|  |  | -+#undef cbrt
 | 
	
		
			
				|  |  | -+#undef cbrtf
 | 
	
		
			
				|  |  | -+#undef cbrtl
 | 
	
		
			
				|  |  | -+#undef copysign
 | 
	
		
			
				|  |  | -+#undef copysignf
 | 
	
		
			
				|  |  | -+#undef copysignl
 | 
	
		
			
				|  |  | -+#undef erf
 | 
	
		
			
				|  |  | -+#undef erff
 | 
	
		
			
				|  |  | -+#undef erfl
 | 
	
		
			
				|  |  | -+#undef erfc
 | 
	
		
			
				|  |  | -+#undef erfcf
 | 
	
		
			
				|  |  | -+#undef erfcl
 | 
	
		
			
				|  |  | -+#undef exp2
 | 
	
		
			
				|  |  | -+#undef exp2f
 | 
	
		
			
				|  |  | -+#undef exp2l
 | 
	
		
			
				|  |  | -+#undef expm1
 | 
	
		
			
				|  |  | -+#undef expm1f
 | 
	
		
			
				|  |  | -+#undef expm1l
 | 
	
		
			
				|  |  | -+#undef fdim
 | 
	
		
			
				|  |  | -+#undef fdimf
 | 
	
		
			
				|  |  | -+#undef fdiml
 | 
	
		
			
				|  |  | -+#undef fma
 | 
	
		
			
				|  |  | -+#undef fmaf
 | 
	
		
			
				|  |  | -+#undef fmal
 | 
	
		
			
				|  |  | -+#undef fmax
 | 
	
		
			
				|  |  | -+#undef fmaxf
 | 
	
		
			
				|  |  | -+#undef fmaxl
 | 
	
		
			
				|  |  | -+#undef fmin
 | 
	
		
			
				|  |  | -+#undef fminf
 | 
	
		
			
				|  |  | -+#undef fminl
 | 
	
		
			
				|  |  | -+#undef hypot
 | 
	
		
			
				|  |  | -+#undef hypotf
 | 
	
		
			
				|  |  | -+#undef hypotl
 | 
	
		
			
				|  |  | -+#undef ilogb
 | 
	
		
			
				|  |  | -+#undef ilogbf
 | 
	
		
			
				|  |  | -+#undef ilogbl
 | 
	
		
			
				|  |  | -+#undef lgamma
 | 
	
		
			
				|  |  | -+#undef lgammaf
 | 
	
		
			
				|  |  | -+#undef lgammal
 | 
	
		
			
				|  |  | -+#undef llrint
 | 
	
		
			
				|  |  | -+#undef llrintf
 | 
	
		
			
				|  |  | -+#undef llrintl
 | 
	
		
			
				|  |  | -+#undef llround
 | 
	
		
			
				|  |  | -+#undef llroundf
 | 
	
		
			
				|  |  | -+#undef llroundl
 | 
	
		
			
				|  |  | -+#undef log1p
 | 
	
		
			
				|  |  | -+#undef log1pf
 | 
	
		
			
				|  |  | -+#undef log1pl
 | 
	
		
			
				|  |  | -+#undef log2
 | 
	
		
			
				|  |  | -+#undef log2f
 | 
	
		
			
				|  |  | -+#undef log2l
 | 
	
		
			
				|  |  | -+#undef logb
 | 
	
		
			
				|  |  | -+#undef logbf
 | 
	
		
			
				|  |  | -+#undef logbl
 | 
	
		
			
				|  |  | -+#undef lrint
 | 
	
		
			
				|  |  | -+#undef lrintf
 | 
	
		
			
				|  |  | -+#undef lrintl
 | 
	
		
			
				|  |  | -+#undef lround
 | 
	
		
			
				|  |  | -+#undef lroundf
 | 
	
		
			
				|  |  | -+#undef lroundl
 | 
	
		
			
				|  |  | -+#undef nan
 | 
	
		
			
				|  |  | -+#undef nanf
 | 
	
		
			
				|  |  | -+#undef nanl
 | 
	
		
			
				|  |  | -+#undef nearbyint
 | 
	
		
			
				|  |  | -+#undef nearbyintf
 | 
	
		
			
				|  |  | -+#undef nearbyintl
 | 
	
		
			
				|  |  | -+#undef nextafter
 | 
	
		
			
				|  |  | -+#undef nextafterf
 | 
	
		
			
				|  |  | -+#undef nextafterl
 | 
	
		
			
				|  |  | -+#undef nexttoward
 | 
	
		
			
				|  |  | -+#undef nexttowardf
 | 
	
		
			
				|  |  | -+#undef nexttowardl
 | 
	
		
			
				|  |  | -+#undef remainder
 | 
	
		
			
				|  |  | -+#undef remainderf
 | 
	
		
			
				|  |  | -+#undef remainderl
 | 
	
		
			
				|  |  | -+#undef remquo
 | 
	
		
			
				|  |  | -+#undef remquof
 | 
	
		
			
				|  |  | -+#undef remquol
 | 
	
		
			
				|  |  | -+#undef rint
 | 
	
		
			
				|  |  | -+#undef rintf
 | 
	
		
			
				|  |  | -+#undef rintl
 | 
	
		
			
				|  |  | -+#undef round
 | 
	
		
			
				|  |  | -+#undef roundf
 | 
	
		
			
				|  |  | -+#undef roundl
 | 
	
		
			
				|  |  | -+#undef scalbln
 | 
	
		
			
				|  |  | -+#undef scalblnf
 | 
	
		
			
				|  |  | -+#undef scalblnl
 | 
	
		
			
				|  |  | -+#undef scalbn
 | 
	
		
			
				|  |  | -+#undef scalbnf
 | 
	
		
			
				|  |  | -+#undef scalbnl
 | 
	
		
			
				|  |  | -+#undef tgamma
 | 
	
		
			
				|  |  | -+#undef tgammaf
 | 
	
		
			
				|  |  | -+#undef tgammal
 | 
	
		
			
				|  |  | -+#undef trunc
 | 
	
		
			
				|  |  | -+#undef truncf
 | 
	
		
			
				|  |  | -+#undef truncl
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+namespace std _GLIBCXX_VISIBILITY(default)
 | 
	
		
			
				|  |  | -+{
 | 
	
		
			
				|  |  | -+namespace tr1
 | 
	
		
			
				|  |  | -+{
 | 
	
		
			
				|  |  | -+_GLIBCXX_BEGIN_NAMESPACE_VERSION
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#if _GLIBCXX_USE_C99_MATH_TR1
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  // types
 | 
	
		
			
				|  |  | -+  using ::double_t;
 | 
	
		
			
				|  |  | -+  using ::float_t;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  // functions
 | 
	
		
			
				|  |  | -+  using ::acosh;
 | 
	
		
			
				|  |  | -+  using ::acoshf;
 | 
	
		
			
				|  |  | -+  using ::acoshl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::asinh;
 | 
	
		
			
				|  |  | -+  using ::asinhf;
 | 
	
		
			
				|  |  | -+  using ::asinhl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::atanh;
 | 
	
		
			
				|  |  | -+  using ::atanhf;
 | 
	
		
			
				|  |  | -+  using ::atanhl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::cbrt;
 | 
	
		
			
				|  |  | -+  using ::cbrtf;
 | 
	
		
			
				|  |  | -+  using ::cbrtl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::copysign;
 | 
	
		
			
				|  |  | -+  using ::copysignf;
 | 
	
		
			
				|  |  | -+  using ::copysignl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::erf;
 | 
	
		
			
				|  |  | -+  using ::erff;
 | 
	
		
			
				|  |  | -+  using ::erfl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::erfc;
 | 
	
		
			
				|  |  | -+  using ::erfcf;
 | 
	
		
			
				|  |  | -+  using ::erfcl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::exp2;
 | 
	
		
			
				|  |  | -+  using ::exp2f;
 | 
	
		
			
				|  |  | -+  using ::exp2l;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::expm1;
 | 
	
		
			
				|  |  | -+  using ::expm1f;
 | 
	
		
			
				|  |  | -+  using ::expm1l;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::fdim;
 | 
	
		
			
				|  |  | -+  using ::fdimf;
 | 
	
		
			
				|  |  | -+  using ::fdiml;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::fma;
 | 
	
		
			
				|  |  | -+  using ::fmaf;
 | 
	
		
			
				|  |  | -+  using ::fmal;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::fmax;
 | 
	
		
			
				|  |  | -+  using ::fmaxf;
 | 
	
		
			
				|  |  | -+  using ::fmaxl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::fmin;
 | 
	
		
			
				|  |  | -+  using ::fminf;
 | 
	
		
			
				|  |  | -+  using ::fminl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::hypot;
 | 
	
		
			
				|  |  | -+  using ::hypotf;
 | 
	
		
			
				|  |  | -+  using ::hypotl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::ilogb;
 | 
	
		
			
				|  |  | -+  using ::ilogbf;
 | 
	
		
			
				|  |  | -+  using ::ilogbl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::lgamma;
 | 
	
		
			
				|  |  | -+  using ::lgammaf;
 | 
	
		
			
				|  |  | -+  using ::lgammal;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::llrint;
 | 
	
		
			
				|  |  | -+  using ::llrintf;
 | 
	
		
			
				|  |  | -+  using ::llrintl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::llround;
 | 
	
		
			
				|  |  | -+  using ::llroundf;
 | 
	
		
			
				|  |  | -+  using ::llroundl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::log1p;
 | 
	
		
			
				|  |  | -+  using ::log1pf;
 | 
	
		
			
				|  |  | -+  using ::log1pl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::log2;
 | 
	
		
			
				|  |  | -+  using ::log2f;
 | 
	
		
			
				|  |  | -+  using ::log2l;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::logb;
 | 
	
		
			
				|  |  | -+  using ::logbf;
 | 
	
		
			
				|  |  | -+  using ::logbl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::lrint;
 | 
	
		
			
				|  |  | -+  using ::lrintf;
 | 
	
		
			
				|  |  | -+  using ::lrintl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::lround;
 | 
	
		
			
				|  |  | -+  using ::lroundf;
 | 
	
		
			
				|  |  | -+  using ::lroundl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::nan;
 | 
	
		
			
				|  |  | -+  using ::nanf;
 | 
	
		
			
				|  |  | -+  using ::nanl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::nearbyint;
 | 
	
		
			
				|  |  | -+  using ::nearbyintf;
 | 
	
		
			
				|  |  | -+  using ::nearbyintl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::nextafter;
 | 
	
		
			
				|  |  | -+  using ::nextafterf;
 | 
	
		
			
				|  |  | -+  using ::nextafterl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::nexttoward;
 | 
	
		
			
				|  |  | -+  using ::nexttowardf;
 | 
	
		
			
				|  |  | -+  using ::nexttowardl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::remainder;
 | 
	
		
			
				|  |  | -+  using ::remainderf;
 | 
	
		
			
				|  |  | -+  using ::remainderl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::remquo;
 | 
	
		
			
				|  |  | -+  using ::remquof;
 | 
	
		
			
				|  |  | -+  using ::remquol;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::rint;
 | 
	
		
			
				|  |  | -+  using ::rintf;
 | 
	
		
			
				|  |  | -+  using ::rintl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::round;
 | 
	
		
			
				|  |  | -+  using ::roundf;
 | 
	
		
			
				|  |  | -+  using ::roundl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::scalbln;
 | 
	
		
			
				|  |  | -+  using ::scalblnf;
 | 
	
		
			
				|  |  | -+  using ::scalblnl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::scalbn;
 | 
	
		
			
				|  |  | -+  using ::scalbnf;
 | 
	
		
			
				|  |  | -+  using ::scalbnl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::tgamma;
 | 
	
		
			
				|  |  | -+  using ::tgammaf;
 | 
	
		
			
				|  |  | -+  using ::tgammal;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using ::trunc;
 | 
	
		
			
				|  |  | -+  using ::truncf;
 | 
	
		
			
				|  |  | -+  using ::truncl;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#if _GLIBCXX_USE_C99_MATH
 | 
	
		
			
				|  |  | -+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  /// Function template definitions [8.16.3].
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    fpclassify(_Tp __f)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
 | 
	
		
			
				|  |  | -+				  FP_SUBNORMAL, FP_ZERO, __type(__f));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isfinite(_Tp __f)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isfinite(__type(__f));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isinf(_Tp __f)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isinf(__type(__f));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isnan(_Tp __f)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isnan(__type(__f));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isnormal(_Tp __f)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isnormal(__type(__f));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    signbit(_Tp __f)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_signbit(__type(__f));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isgreater(_Tp __f1, _Tp __f2)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isgreater(__type(__f1), __type(__f2));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isgreaterequal(_Tp __f1, _Tp __f2)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isless(_Tp __f1, _Tp __f2)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isless(__type(__f1), __type(__f2));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    islessequal(_Tp __f1, _Tp __f2)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_islessequal(__type(__f1), __type(__f2));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    islessgreater(_Tp __f1, _Tp __f2)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_islessgreater(__type(__f1), __type(__f2));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    isunordered(_Tp __f1, _Tp __f2)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __builtin_isunordered(__type(__f1), __type(__f2));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#if _GLIBCXX_USE_C99_MATH_TR1
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  /// Additional overloads [8.16.4].
 | 
	
		
			
				|  |  | -+  using std::acos;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  acosh(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_acoshf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  acosh(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_acoshl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    acosh(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_acosh(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::asin;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  asinh(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_asinhf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  asinh(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_asinhl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    asinh(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_asinh(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::atan;
 | 
	
		
			
				|  |  | -+  using std::atan2;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  atanh(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_atanhf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  atanh(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_atanhl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    atanh(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_atanh(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  cbrt(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_cbrtf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  cbrt(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_cbrtl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    cbrt(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_cbrt(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::ceil;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  copysign(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_copysignf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  copysign(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_copysignl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    copysign(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return copysign(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::cos;
 | 
	
		
			
				|  |  | -+  using std::cosh;  
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  erf(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_erff(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  erf(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_erfl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    erf(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_erf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  erfc(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_erfcf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  erfc(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_erfcl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    erfc(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_erfc(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::exp;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  exp2(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_exp2f(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  exp2(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_exp2l(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    exp2(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_exp2(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  expm1(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_expm1f(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  expm1(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_expm1l(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    expm1(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_expm1(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  // Note: we deal with fabs in a special way, because an using std::fabs
 | 
	
		
			
				|  |  | -+  // would bring in also the overloads for complex types, which in C++0x
 | 
	
		
			
				|  |  | -+  // mode have a different return type.
 | 
	
		
			
				|  |  | -+  // With __CORRECT_ISO_CPP_MATH_H_PROTO, math.h imports std::fabs in the
 | 
	
		
			
				|  |  | -+  // global namespace after the declarations of the float / double / long
 | 
	
		
			
				|  |  | -+  // double overloads but before the std::complex overloads.
 | 
	
		
			
				|  |  | -+  using ::fabs;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  fabs(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_fabsf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  fabs(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_fabsl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    fabs(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_fabs(__x); }
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  fdim(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_fdimf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  fdim(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_fdiml(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    fdim(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return fdim(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::floor;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  fma(float __x, float __y, float __z)
 | 
	
		
			
				|  |  | -+  { return __builtin_fmaf(__x, __y, __z); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  fma(long double __x, long double __y, long double __z)
 | 
	
		
			
				|  |  | -+  { return __builtin_fmal(__x, __y, __z); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up, typename _Vp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
 | 
	
		
			
				|  |  | -+    fma(_Tp __x, _Up __y, _Vp __z)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
 | 
	
		
			
				|  |  | -+      return fma(__type(__x), __type(__y), __type(__z));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  fmax(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_fmaxf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  fmax(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_fmaxl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    fmax(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return fmax(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  fmin(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_fminf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  fmin(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_fminl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    fmin(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return fmin(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::fmod;
 | 
	
		
			
				|  |  | -+  using std::frexp;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  hypot(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_hypotf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  hypot(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_hypotl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    hypot(_Tp __y, _Up __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return hypot(__type(__y), __type(__x));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline int
 | 
	
		
			
				|  |  | -+  ilogb(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_ilogbf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline int
 | 
	
		
			
				|  |  | -+  ilogb(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_ilogbl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   int>::__type
 | 
	
		
			
				|  |  | -+    ilogb(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_ilogb(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::ldexp;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  lgamma(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_lgammaf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  lgamma(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_lgammal(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    lgamma(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_lgamma(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long long
 | 
	
		
			
				|  |  | -+  llrint(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_llrintf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long long
 | 
	
		
			
				|  |  | -+  llrint(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_llrintl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   long long>::__type
 | 
	
		
			
				|  |  | -+    llrint(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_llrint(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long long
 | 
	
		
			
				|  |  | -+  llround(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_llroundf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long long
 | 
	
		
			
				|  |  | -+  llround(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_llroundl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   long long>::__type
 | 
	
		
			
				|  |  | -+    llround(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_llround(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::log;
 | 
	
		
			
				|  |  | -+  using std::log10;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  log1p(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_log1pf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  log1p(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_log1pl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    log1p(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_log1p(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  // DR 568.
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  log2(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_log2f(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  log2(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_log2l(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    log2(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_log2(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  logb(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_logbf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  logb(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_logbl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    logb(_Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      return __builtin_logb(__x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long
 | 
	
		
			
				|  |  | -+  lrint(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_lrintf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long
 | 
	
		
			
				|  |  | -+  lrint(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_lrintl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   long>::__type
 | 
	
		
			
				|  |  | -+    lrint(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_lrint(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long
 | 
	
		
			
				|  |  | -+  lround(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_lroundf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long
 | 
	
		
			
				|  |  | -+  lround(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_lroundl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   long>::__type
 | 
	
		
			
				|  |  | -+    lround(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_lround(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  nearbyint(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_nearbyintf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  nearbyint(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_nearbyintl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    nearbyint(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_nearbyint(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  nextafter(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_nextafterf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  nextafter(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_nextafterl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    nextafter(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return nextafter(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  nexttoward(float __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_nexttowardf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  nexttoward(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_nexttowardl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    nexttoward(_Tp __x, long double __y)
 | 
	
		
			
				|  |  | -+    { return __builtin_nexttoward(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  // DR 550. What should the return type of pow(float,int) be?
 | 
	
		
			
				|  |  | -+  // NB: C++0x and TR1 != C++03.
 | 
	
		
			
				|  |  | -+  //   using std::pow;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  remainder(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_remainderf(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  remainder(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __builtin_remainderl(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    remainder(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return remainder(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  remquo(float __x, float __y, int* __pquo)
 | 
	
		
			
				|  |  | -+  { return __builtin_remquof(__x, __y, __pquo); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  remquo(long double __x, long double __y, int* __pquo)
 | 
	
		
			
				|  |  | -+  { return __builtin_remquol(__x, __y, __pquo); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    remquo(_Tp __x, _Up __y, int* __pquo)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return remquo(__type(__x), __type(__y), __pquo);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  rint(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_rintf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  rint(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_rintl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    rint(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_rint(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  round(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_roundf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  round(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_roundl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    round(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_round(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  scalbln(float __x, long __ex)
 | 
	
		
			
				|  |  | -+  { return __builtin_scalblnf(__x, __ex); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  scalbln(long double __x, long __ex)
 | 
	
		
			
				|  |  | -+  { return __builtin_scalblnl(__x, __ex); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    scalbln(_Tp __x, long __ex)
 | 
	
		
			
				|  |  | -+    { return __builtin_scalbln(__x, __ex); }
 | 
	
		
			
				|  |  | -+ 
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  scalbn(float __x, int __ex)
 | 
	
		
			
				|  |  | -+  { return __builtin_scalbnf(__x, __ex); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  scalbn(long double __x, int __ex)
 | 
	
		
			
				|  |  | -+  { return __builtin_scalbnl(__x, __ex); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    scalbn(_Tp __x, int __ex)
 | 
	
		
			
				|  |  | -+    { return __builtin_scalbn(__x, __ex); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  using std::sin;
 | 
	
		
			
				|  |  | -+  using std::sinh;
 | 
	
		
			
				|  |  | -+  using std::sqrt;
 | 
	
		
			
				|  |  | -+  using std::tan;
 | 
	
		
			
				|  |  | -+  using std::tanh;
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  tgamma(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_tgammaf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  tgamma(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_tgammal(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    tgamma(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_tgamma(__x); }
 | 
	
		
			
				|  |  | -+ 
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  trunc(float __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_truncf(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  trunc(long double __x)
 | 
	
		
			
				|  |  | -+  { return __builtin_truncl(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
 | 
	
		
			
				|  |  | -+					   double>::__type
 | 
	
		
			
				|  |  | -+    trunc(_Tp __x)
 | 
	
		
			
				|  |  | -+    { return __builtin_trunc(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#endif
 | 
	
		
			
				|  |  | -+_GLIBCXX_END_NAMESPACE_VERSION
 | 
	
		
			
				|  |  | -+}
 | 
	
		
			
				|  |  | -+}
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+namespace std _GLIBCXX_VISIBILITY(default)
 | 
	
		
			
				|  |  | -+{
 | 
	
		
			
				|  |  | -+namespace tr1
 | 
	
		
			
				|  |  | -+{
 | 
	
		
			
				|  |  | -+_GLIBCXX_BEGIN_NAMESPACE_VERSION
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  // DR 550. What should the return type of pow(float,int) be?
 | 
	
		
			
				|  |  | -+  // NB: C++0x and TR1 != C++03.
 | 
	
		
			
				|  |  | -+  inline double
 | 
	
		
			
				|  |  | -+  pow(double __x, double __y)
 | 
	
		
			
				|  |  | -+  { return std::pow(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  pow(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return std::pow(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  pow(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return std::pow(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Up>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 | 
	
		
			
				|  |  | -+    pow(_Tp __x, _Up __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 | 
	
		
			
				|  |  | -+      return std::pow(__type(__x), __type(__y));
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+_GLIBCXX_END_NAMESPACE_VERSION
 | 
	
		
			
				|  |  | -+}
 | 
	
		
			
				|  |  | -+}
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#include <bits/stl_algobase.h>
 | 
	
		
			
				|  |  | -+#include <limits>
 | 
	
		
			
				|  |  | -+#include <tr1/type_traits>
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#include <tr1/gamma.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/bessel_function.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/beta_function.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/ell_integral.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/exp_integral.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/hypergeometric.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/legendre_function.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/modified_bessel_func.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/poly_hermite.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/poly_laguerre.tcc>
 | 
	
		
			
				|  |  | -+#include <tr1/riemann_zeta.tcc>
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+namespace std _GLIBCXX_VISIBILITY(default)
 | 
	
		
			
				|  |  | -+{
 | 
	
		
			
				|  |  | -+namespace tr1
 | 
	
		
			
				|  |  | -+{
 | 
	
		
			
				|  |  | -+_GLIBCXX_BEGIN_NAMESPACE_VERSION
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  /**
 | 
	
		
			
				|  |  | -+   * @defgroup tr1_math_spec_func Mathematical Special Functions
 | 
	
		
			
				|  |  | -+   * @ingroup numerics
 | 
	
		
			
				|  |  | -+   *
 | 
	
		
			
				|  |  | -+   * A collection of advanced mathematical special functions.
 | 
	
		
			
				|  |  | -+   * @{
 | 
	
		
			
				|  |  | -+   */
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
 | 
	
		
			
				|  |  | -+  {
 | 
	
		
			
				|  |  | -+    return __detail::__assoc_laguerre<long double>(__n, __m, __x);
 | 
	
		
			
				|  |  | -+  }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.1  Associated Laguerre polynomials.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.2  Associated Legendre functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  betaf(float __x, float __y)
 | 
	
		
			
				|  |  | -+  { return __detail::__beta<float>(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  betal(long double __x, long double __y)
 | 
	
		
			
				|  |  | -+  { return __detail::__beta<long double>(__x, __y); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.3  Beta functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tpx, typename _Tpy>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
 | 
	
		
			
				|  |  | -+    beta(_Tpx __x, _Tpy __y)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__beta<__type>(__x, __y);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  comp_ellint_1f(float __k)
 | 
	
		
			
				|  |  | -+  { return __detail::__comp_ellint_1<float>(__k); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  comp_ellint_1l(long double __k)
 | 
	
		
			
				|  |  | -+  { return __detail::__comp_ellint_1<long double>(__k); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.4  Complete elliptic integrals of the first kind.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    comp_ellint_1(_Tp __k)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__comp_ellint_1<__type>(__k);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  comp_ellint_2f(float __k)
 | 
	
		
			
				|  |  | -+  { return __detail::__comp_ellint_2<float>(__k); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  comp_ellint_2l(long double __k)
 | 
	
		
			
				|  |  | -+  { return __detail::__comp_ellint_2<long double>(__k); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.5  Complete elliptic integrals of the second kind.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    comp_ellint_2(_Tp __k)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__comp_ellint_2<__type>(__k);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  comp_ellint_3f(float __k, float __nu)
 | 
	
		
			
				|  |  | -+  { return __detail::__comp_ellint_3<float>(__k, __nu); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  comp_ellint_3l(long double __k, long double __nu)
 | 
	
		
			
				|  |  | -+  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.6  Complete elliptic integrals of the third kind.
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Tpn>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
 | 
	
		
			
				|  |  | -+    comp_ellint_3(_Tp __k, _Tpn __nu)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__comp_ellint_3<__type>(__k, __nu);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  conf_hypergf(float __a, float __c, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__conf_hyperg<float>(__a, __c, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  conf_hypergl(long double __a, long double __c, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__conf_hyperg<long double>(__a, __c, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.7  Confluent hypergeometric functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tpa, typename _Tpc, typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
 | 
	
		
			
				|  |  | -+    conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__conf_hyperg<__type>(__a, __c, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  cyl_bessel_if(float __nu, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_bessel_i<float>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  cyl_bessel_il(long double __nu, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.8  Regular modified cylindrical Bessel functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tpnu, typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
 | 
	
		
			
				|  |  | -+    cyl_bessel_i(_Tpnu __nu, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__cyl_bessel_i<__type>(__nu, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  cyl_bessel_jf(float __nu, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_bessel_j<float>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  cyl_bessel_jl(long double __nu, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.9  Cylindrical Bessel functions (of the first kind).
 | 
	
		
			
				|  |  | -+  template<typename _Tpnu, typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
 | 
	
		
			
				|  |  | -+    cyl_bessel_j(_Tpnu __nu, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__cyl_bessel_j<__type>(__nu, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  cyl_bessel_kf(float __nu, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_bessel_k<float>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  cyl_bessel_kl(long double __nu, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.10  Irregular modified cylindrical Bessel functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tpnu, typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
 | 
	
		
			
				|  |  | -+    cyl_bessel_k(_Tpnu __nu, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__cyl_bessel_k<__type>(__nu, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  cyl_neumannf(float __nu, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_neumann_n<float>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  cyl_neumannl(long double __nu, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.11  Cylindrical Neumann functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tpnu, typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
 | 
	
		
			
				|  |  | -+    cyl_neumann(_Tpnu __nu, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__cyl_neumann_n<__type>(__nu, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  ellint_1f(float __k, float __phi)
 | 
	
		
			
				|  |  | -+  { return __detail::__ellint_1<float>(__k, __phi); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  ellint_1l(long double __k, long double __phi)
 | 
	
		
			
				|  |  | -+  { return __detail::__ellint_1<long double>(__k, __phi); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.12  Incomplete elliptic integrals of the first kind.
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Tpp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
 | 
	
		
			
				|  |  | -+    ellint_1(_Tp __k, _Tpp __phi)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__ellint_1<__type>(__k, __phi);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  ellint_2f(float __k, float __phi)
 | 
	
		
			
				|  |  | -+  { return __detail::__ellint_2<float>(__k, __phi); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  ellint_2l(long double __k, long double __phi)
 | 
	
		
			
				|  |  | -+  { return __detail::__ellint_2<long double>(__k, __phi); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.13  Incomplete elliptic integrals of the second kind.
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Tpp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
 | 
	
		
			
				|  |  | -+    ellint_2(_Tp __k, _Tpp __phi)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__ellint_2<__type>(__k, __phi);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  ellint_3f(float __k, float __nu, float __phi)
 | 
	
		
			
				|  |  | -+  { return __detail::__ellint_3<float>(__k, __nu, __phi); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  ellint_3l(long double __k, long double __nu, long double __phi)
 | 
	
		
			
				|  |  | -+  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.14  Incomplete elliptic integrals of the third kind.
 | 
	
		
			
				|  |  | -+  template<typename _Tp, typename _Tpn, typename _Tpp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
 | 
	
		
			
				|  |  | -+    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__ellint_3<__type>(__k, __nu, __phi);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  expintf(float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__expint<float>(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  expintl(long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__expint<long double>(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.15  Exponential integrals.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    expint(_Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__expint<__type>(__x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  hermitef(unsigned int __n, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__poly_hermite<float>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  hermitel(unsigned int __n, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__poly_hermite<long double>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.16  Hermite polynomials.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    hermite(unsigned int __n, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__poly_hermite<__type>(__n, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  hypergf(float __a, float __b, float __c, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__hyperg<float>(__a, __b, __c, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  hypergl(long double __a, long double __b, long double __c, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__hyperg<long double>(__a, __b, __c, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.17  Hypergeometric functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
 | 
	
		
			
				|  |  | -+    hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__hyperg<__type>(__a, __b, __c, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  laguerref(unsigned int __n, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__laguerre<float>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  laguerrel(unsigned int __n, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__laguerre<long double>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.18  Laguerre polynomials.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    laguerre(unsigned int __n, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__laguerre<__type>(__n, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  legendref(unsigned int __n, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__poly_legendre_p<float>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  legendrel(unsigned int __n, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__poly_legendre_p<long double>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.19  Legendre polynomials.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    legendre(unsigned int __n, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__poly_legendre_p<__type>(__n, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  riemann_zetaf(float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__riemann_zeta<float>(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  riemann_zetal(long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__riemann_zeta<long double>(__x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.20  Riemann zeta function.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    riemann_zeta(_Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__riemann_zeta<__type>(__x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  sph_besself(unsigned int __n, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__sph_bessel<float>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  sph_bessell(unsigned int __n, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__sph_bessel<long double>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.21  Spherical Bessel functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    sph_bessel(unsigned int __n, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__sph_bessel<__type>(__n, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
 | 
	
		
			
				|  |  | -+  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
 | 
	
		
			
				|  |  | -+  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.22  Spherical associated Legendre functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__sph_legendre<__type>(__l, __m, __theta);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline float
 | 
	
		
			
				|  |  | -+  sph_neumannf(unsigned int __n, float __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__sph_neumann<float>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  inline long double
 | 
	
		
			
				|  |  | -+  sph_neumannl(unsigned int __n, long double __x)
 | 
	
		
			
				|  |  | -+  { return __detail::__sph_neumann<long double>(__n, __x); }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  ///  5.2.1.23  Spherical Neumann functions.
 | 
	
		
			
				|  |  | -+  template<typename _Tp>
 | 
	
		
			
				|  |  | -+    inline typename __gnu_cxx::__promote<_Tp>::__type
 | 
	
		
			
				|  |  | -+    sph_neumann(unsigned int __n, _Tp __x)
 | 
	
		
			
				|  |  | -+    {
 | 
	
		
			
				|  |  | -+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 | 
	
		
			
				|  |  | -+      return __detail::__sph_neumann<__type>(__n, __x);
 | 
	
		
			
				|  |  | -+    }
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+  /* @} */ // tr1_math_spec_func
 | 
	
		
			
				|  |  | -+_GLIBCXX_END_NAMESPACE_VERSION
 | 
	
		
			
				|  |  | -+}
 | 
	
		
			
				|  |  | -+}
 | 
	
		
			
				|  |  | -+
 | 
	
		
			
				|  |  | -+#endif // _GLIBCXX_TR1_CMATH
 |