File Coverage

/usr/include/c++/5/cmath

Criterion	Covered	Total	%
statement	2	2	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	2	2	100.0

line	stmt	code
1		// -- C++ -- C forwarding header.
2
3		// Copyright (C) 1997-2015 Free Software Foundation, Inc.
4		//
5		// This file is part of the GNU ISO C++ Library. This library is free
6		// software; you can redistribute it and/or modify it under the
7		// terms of the GNU General Public License as published by the
8		// Free Software Foundation; either version 3, or (at your option)
9		// any later version.
10
11		// This library is distributed in the hope that it will be useful,
12		// but WITHOUT ANY WARRANTY; without even the implied warranty of
13		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14		// GNU General Public License for more details.
15
16		// Under Section 7 of GPL version 3, you are granted additional
17		// permissions described in the GCC Runtime Library Exception, version
18		// 3.1, as published by the Free Software Foundation.
19
20		// You should have received a copy of the GNU General Public License and
21		// a copy of the GCC Runtime Library Exception along with this program;
22		// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23		// .
24
25		/** @file include/cmath
26		* This is a Standard C++ Library file. You should @c \#include this file
27		* in your programs, rather than any of the @a *.h implementation files.
28		*
29		* This is the C++ version of the Standard C Library header @c math.h,
30		* and its contents are (mostly) the same as that header, but are all
31		* contained in the namespace @c std (except for names which are defined
32		* as macros in C).
33		*/
34
35		//
36		// ISO C++ 14882: 26.5 C library
37		//
38
39		#pragma GCC system_header
40
41		#include
42		#include
43		#include
44		#include
45
46		#ifndef _GLIBCXX_CMATH
47		#define _GLIBCXX_CMATH 1
48
49		// Get rid of those macros defined in in lieu of real functions.
50		#undef abs
51		#undef div
52		#undef acos
53		#undef asin
54		#undef atan
55		#undef atan2
56		#undef ceil
57		#undef cos
58		#undef cosh
59		#undef exp
60		#undef fabs
61		#undef floor
62		#undef fmod
63		#undef frexp
64		#undef ldexp
65		#undef log
66		#undef log10
67		#undef modf
68		#undef pow
69		#undef sin
70		#undef sinh
71		#undef sqrt
72		#undef tan
73		#undef tanh
74
75		namespace std _GLIBCXX_VISIBILITY(default)
76		{
77		_GLIBCXX_BEGIN_NAMESPACE_VERSION
78
79		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
80		inline _GLIBCXX_CONSTEXPR double
81		abs(double __x)
82		{ return __builtin_fabs(__x); }
83		#endif
84
85		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
86		inline _GLIBCXX_CONSTEXPR float
87		abs(float __x)
88		{ return __builtin_fabsf(__x); }
89
90		inline _GLIBCXX_CONSTEXPR long double
91		abs(long double __x)
92		{ return __builtin_fabsl(__x); }
93		#endif
94
95		template
96		inline _GLIBCXX_CONSTEXPR
97		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
98		double>::__type
99		abs(_Tp __x)
100		{ return __builtin_fabs(__x); }
101
102		using ::acos;
103
104		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
105		inline _GLIBCXX_CONSTEXPR float
106		acos(float __x)
107		{ return __builtin_acosf(__x); }
108
109		inline _GLIBCXX_CONSTEXPR long double
110		acos(long double __x)
111		{ return __builtin_acosl(__x); }
112		#endif
113
114		template
115		inline _GLIBCXX_CONSTEXPR
116		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
117		double>::__type
118		acos(_Tp __x)
119		{ return __builtin_acos(__x); }
120
121		using ::asin;
122
123		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
124		inline _GLIBCXX_CONSTEXPR float
125		asin(float __x)
126		{ return __builtin_asinf(__x); }
127
128		inline _GLIBCXX_CONSTEXPR long double
129		asin(long double __x)
130		{ return __builtin_asinl(__x); }
131		#endif
132
133		template
134		inline _GLIBCXX_CONSTEXPR
135		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
136		double>::__type
137		asin(_Tp __x)
138		{ return __builtin_asin(__x); }
139
140		using ::atan;
141
142		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
143		inline _GLIBCXX_CONSTEXPR float
144		atan(float __x)
145		{ return __builtin_atanf(__x); }
146
147		inline _GLIBCXX_CONSTEXPR long double
148		atan(long double __x)
149		{ return __builtin_atanl(__x); }
150		#endif
151
152		template
153		inline _GLIBCXX_CONSTEXPR
154		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
155		double>::__type
156		atan(_Tp __x)
157		{ return __builtin_atan(__x); }
158
159		using ::atan2;
160
161		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
162		inline _GLIBCXX_CONSTEXPR float
163		atan2(float __y, float __x)
164		{ return __builtin_atan2f(__y, __x); }
165
166		inline _GLIBCXX_CONSTEXPR long double
167		atan2(long double __y, long double __x)
168		{ return __builtin_atan2l(__y, __x); }
169		#endif
170
171		template
172		inline _GLIBCXX_CONSTEXPR
173		typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
174		atan2(_Tp __y, _Up __x)
175		{
176		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
177		return atan2(__type(__y), __type(__x));
178		}
179
180		using ::ceil;
181
182		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
183		inline _GLIBCXX_CONSTEXPR float
184		ceil(float __x)
185		{ return __builtin_ceilf(__x); }
186
187		inline _GLIBCXX_CONSTEXPR long double
188		ceil(long double __x)
189		{ return __builtin_ceill(__x); }
190		#endif
191
192		template
193		inline _GLIBCXX_CONSTEXPR
194		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
195		double>::__type
196		ceil(_Tp __x)
197		{ return __builtin_ceil(__x); }
198
199		using ::cos;
200
201		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
202		inline _GLIBCXX_CONSTEXPR float
203		cos(float __x)
204		{ return __builtin_cosf(__x); }
205
206		inline _GLIBCXX_CONSTEXPR long double
207		cos(long double __x)
208		{ return __builtin_cosl(__x); }
209		#endif
210
211		template
212		inline _GLIBCXX_CONSTEXPR
213		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
214		double>::__type
215		cos(_Tp __x)
216		{ return __builtin_cos(__x); }
217
218		using ::cosh;
219
220		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
221		inline _GLIBCXX_CONSTEXPR float
222		cosh(float __x)
223		{ return __builtin_coshf(__x); }
224
225		inline _GLIBCXX_CONSTEXPR long double
226		cosh(long double __x)
227		{ return __builtin_coshl(__x); }
228		#endif
229
230		template
231		inline _GLIBCXX_CONSTEXPR
232		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
233		double>::__type
234		cosh(_Tp __x)
235		{ return __builtin_cosh(__x); }
236
237		using ::exp;
238
239		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
240		inline _GLIBCXX_CONSTEXPR float
241		exp(float __x)
242		{ return __builtin_expf(__x); }
243
244		inline _GLIBCXX_CONSTEXPR long double
245		exp(long double __x)
246		{ return __builtin_expl(__x); }
247		#endif
248
249		template
250		inline _GLIBCXX_CONSTEXPR
251		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
252		double>::__type
253		exp(_Tp __x)
254		{ return __builtin_exp(__x); }
255
256		using ::fabs;
257
258		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
259		inline _GLIBCXX_CONSTEXPR float
260		fabs(float __x)
261		{ return __builtin_fabsf(__x); }
262
263		inline _GLIBCXX_CONSTEXPR long double
264		fabs(long double __x)
265		{ return __builtin_fabsl(__x); }
266		#endif
267
268		template
269		inline _GLIBCXX_CONSTEXPR
270		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
271		double>::__type
272		fabs(_Tp __x)
273		{ return __builtin_fabs(__x); }
274
275		using ::floor;
276
277		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
278		inline _GLIBCXX_CONSTEXPR float
279		floor(float __x)
280		{ return __builtin_floorf(__x); }
281
282		inline _GLIBCXX_CONSTEXPR long double
283		floor(long double __x)
284		{ return __builtin_floorl(__x); }
285		#endif
286
287		template
288		inline _GLIBCXX_CONSTEXPR
289		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
290		double>::__type
291		floor(_Tp __x)
292		{ return __builtin_floor(__x); }
293
294		using ::fmod;
295
296		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
297		inline _GLIBCXX_CONSTEXPR float
298		fmod(float __x, float __y)
299		{ return __builtin_fmodf(__x, __y); }
300
301		inline _GLIBCXX_CONSTEXPR long double
302		fmod(long double __x, long double __y)
303		{ return __builtin_fmodl(__x, __y); }
304		#endif
305
306		template
307		inline _GLIBCXX_CONSTEXPR
308		typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
309		fmod(_Tp __x, _Up __y)
310		{
311		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
312		return fmod(__type(__x), __type(__y));
313		}
314
315		using ::frexp;
316
317		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
318		inline float
319		frexp(float __x, int* __exp)
320		{ return __builtin_frexpf(__x, __exp); }
321
322		inline long double
323		frexp(long double __x, int* __exp)
324		{ return __builtin_frexpl(__x, __exp); }
325		#endif
326
327		template
328		inline _GLIBCXX_CONSTEXPR
329		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
330		double>::__type
331		frexp(_Tp __x, int* __exp)
332		{ return __builtin_frexp(__x, __exp); }
333
334		using ::ldexp;
335
336		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
337		inline _GLIBCXX_CONSTEXPR float
338		ldexp(float __x, int __exp)
339		{ return __builtin_ldexpf(__x, __exp); }
340
341		inline _GLIBCXX_CONSTEXPR long double
342		ldexp(long double __x, int __exp)
343		{ return __builtin_ldexpl(__x, __exp); }
344		#endif
345
346		template
347		inline _GLIBCXX_CONSTEXPR
348		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
349		double>::__type
350		ldexp(_Tp __x, int __exp)
351		{ return __builtin_ldexp(__x, __exp); }
352
353		using ::log;
354
355		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
356		inline _GLIBCXX_CONSTEXPR float
357		log(float __x)
358		{ return __builtin_logf(__x); }
359
360		inline _GLIBCXX_CONSTEXPR long double
361		log(long double __x)
362		{ return __builtin_logl(__x); }
363		#endif
364
365		template
366		inline _GLIBCXX_CONSTEXPR
367		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
368		double>::__type
369	8	log(_Tp __x)
370	8	{ return __builtin_log(__x); }
371
372		using ::log10;
373
374		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
375		inline _GLIBCXX_CONSTEXPR float
376		log10(float __x)
377		{ return __builtin_log10f(__x); }
378
379		inline _GLIBCXX_CONSTEXPR long double
380		log10(long double __x)
381		{ return __builtin_log10l(__x); }
382		#endif
383
384		template
385		inline _GLIBCXX_CONSTEXPR
386		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
387		double>::__type
388		log10(_Tp __x)
389		{ return __builtin_log10(__x); }
390
391		using ::modf;
392
393		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
394		inline float
395		modf(float __x, float* __iptr)
396		{ return __builtin_modff(__x, __iptr); }
397
398		inline long double
399		modf(long double __x, long double* __iptr)
400		{ return __builtin_modfl(__x, __iptr); }
401		#endif
402
403		using ::pow;
404
405		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
406		inline _GLIBCXX_CONSTEXPR float
407		pow(float __x, float __y)
408		{ return __builtin_powf(__x, __y); }
409
410		inline _GLIBCXX_CONSTEXPR long double
411		pow(long double __x, long double __y)
412		{ return __builtin_powl(__x, __y); }
413
414		#if __cplusplus < 201103L
415		// _GLIBCXX_RESOLVE_LIB_DEFECTS
416		// DR 550. What should the return type of pow(float,int) be?
417		inline double
418		pow(double __x, int __i)
419		{ return __builtin_powi(__x, __i); }
420
421		inline float
422		pow(float __x, int __n)
423		{ return __builtin_powif(__x, __n); }
424
425		inline long double
426		pow(long double __x, int __n)
427		{ return __builtin_powil(__x, __n); }
428		#endif
429		#endif
430
431		template
432		inline _GLIBCXX_CONSTEXPR
433		typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
434		pow(_Tp __x, _Up __y)
435		{
436		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
437		return pow(__type(__x), __type(__y));
438		}
439
440		using ::sin;
441
442		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
443		inline _GLIBCXX_CONSTEXPR float
444		sin(float __x)
445		{ return __builtin_sinf(__x); }
446
447		inline _GLIBCXX_CONSTEXPR long double
448		sin(long double __x)
449		{ return __builtin_sinl(__x); }
450		#endif
451
452		template
453		inline _GLIBCXX_CONSTEXPR
454		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
455		double>::__type
456		sin(_Tp __x)
457		{ return __builtin_sin(__x); }
458
459		using ::sinh;
460
461		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
462		inline _GLIBCXX_CONSTEXPR float
463		sinh(float __x)
464		{ return __builtin_sinhf(__x); }
465
466		inline _GLIBCXX_CONSTEXPR long double
467		sinh(long double __x)
468		{ return __builtin_sinhl(__x); }
469		#endif
470
471		template
472		inline _GLIBCXX_CONSTEXPR
473		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
474		double>::__type
475		sinh(_Tp __x)
476		{ return __builtin_sinh(__x); }
477
478		using ::sqrt;
479
480		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
481		inline _GLIBCXX_CONSTEXPR float
482		sqrt(float __x)
483		{ return __builtin_sqrtf(__x); }
484
485		inline _GLIBCXX_CONSTEXPR long double
486		sqrt(long double __x)
487		{ return __builtin_sqrtl(__x); }
488		#endif
489
490		template
491		inline _GLIBCXX_CONSTEXPR
492		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
493		double>::__type
494		sqrt(_Tp __x)
495		{ return __builtin_sqrt(__x); }
496
497		using ::tan;
498
499		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
500		inline _GLIBCXX_CONSTEXPR float
501		tan(float __x)
502		{ return __builtin_tanf(__x); }
503
504		inline _GLIBCXX_CONSTEXPR long double
505		tan(long double __x)
506		{ return __builtin_tanl(__x); }
507		#endif
508
509		template
510		inline _GLIBCXX_CONSTEXPR
511		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
512		double>::__type
513		tan(_Tp __x)
514		{ return __builtin_tan(__x); }
515
516		using ::tanh;
517
518		#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
519		inline _GLIBCXX_CONSTEXPR float
520		tanh(float __x)
521		{ return __builtin_tanhf(__x); }
522
523		inline _GLIBCXX_CONSTEXPR long double
524		tanh(long double __x)
525		{ return __builtin_tanhl(__x); }
526		#endif
527
528		template
529		inline _GLIBCXX_CONSTEXPR
530		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
531		double>::__type
532		tanh(_Tp __x)
533		{ return __builtin_tanh(__x); }
534
535		_GLIBCXX_END_NAMESPACE_VERSION
536		} // namespace
537
538		#if _GLIBCXX_USE_C99_MATH
539		#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
540
541		// These are possible macros imported from C99-land.
542		#undef fpclassify
543		#undef isfinite
544		#undef isinf
545		#undef isnan
546		#undef isnormal
547		#undef signbit
548		#undef isgreater
549		#undef isgreaterequal
550		#undef isless
551		#undef islessequal
552		#undef islessgreater
553		#undef isunordered
554
555		namespace std _GLIBCXX_VISIBILITY(default)
556		{
557		_GLIBCXX_BEGIN_NAMESPACE_VERSION
558
559		#if __cplusplus >= 201103L
560
561		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
562		constexpr int
563		fpclassify(float __x)
564		{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
565		FP_SUBNORMAL, FP_ZERO, __x); }
566
567		constexpr int
568		fpclassify(double __x)
569		{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
570		FP_SUBNORMAL, FP_ZERO, __x); }
571
572		constexpr int
573		fpclassify(long double __x)
574		{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
575		FP_SUBNORMAL, FP_ZERO, __x); }
576		#endif
577
578		template
579		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
580		int>::__type
581		fpclassify(_Tp __x)
582		{ return __x != 0 ? FP_NORMAL : FP_ZERO; }
583
584		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
585		constexpr bool
586		isfinite(float __x)
587		{ return __builtin_isfinite(__x); }
588
589		constexpr bool
590		isfinite(double __x)
591		{ return __builtin_isfinite(__x); }
592
593		constexpr bool
594		isfinite(long double __x)
595		{ return __builtin_isfinite(__x); }
596		#endif
597
598		template
599		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
600		bool>::__type
601		isfinite(_Tp __x)
602		{ return true; }
603
604		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
605		constexpr bool
606		isinf(float __x)
607		{ return __builtin_isinf(__x); }
608
609		constexpr bool
610		isinf(double __x)
611		{ return __builtin_isinf(__x); }
612
613		constexpr bool
614		isinf(long double __x)
615		{ return __builtin_isinf(__x); }
616		#endif
617
618		template
619		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
620		bool>::__type
621		isinf(_Tp __x)
622		{ return false; }
623
624		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
625		constexpr bool
626		isnan(float __x)
627		{ return __builtin_isnan(__x); }
628
629		constexpr bool
630		isnan(double __x)
631		{ return __builtin_isnan(__x); }
632
633		constexpr bool
634		isnan(long double __x)
635		{ return __builtin_isnan(__x); }
636		#endif
637
638		template
639		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
640		bool>::__type
641		isnan(_Tp __x)
642		{ return false; }
643
644		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
645		constexpr bool
646		isnormal(float __x)
647		{ return __builtin_isnormal(__x); }
648
649		constexpr bool
650		isnormal(double __x)
651		{ return __builtin_isnormal(__x); }
652
653		constexpr bool
654		isnormal(long double __x)
655		{ return __builtin_isnormal(__x); }
656		#endif
657
658		template
659		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
660		bool>::__type
661		isnormal(_Tp __x)
662		{ return __x != 0 ? true : false; }
663
664		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
665		// The front-end doesn't provide a type generic builtin (libstdc++/58625).
666		constexpr bool
667		signbit(float __x)
668		{ return __builtin_signbitf(__x); }
669
670		constexpr bool
671		signbit(double __x)
672		{ return __builtin_signbit(__x); }
673
674		constexpr bool
675		signbit(long double __x)
676		{ return __builtin_signbitl(__x); }
677		#endif
678
679		template
680		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
681		bool>::__type
682		signbit(_Tp __x)
683		{ return __x < 0 ? true : false; }
684
685		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
686		constexpr bool
687		isgreater(float __x, float __y)
688		{ return __builtin_isgreater(__x, __y); }
689
690		constexpr bool
691		isgreater(double __x, double __y)
692		{ return __builtin_isgreater(__x, __y); }
693
694		constexpr bool
695		isgreater(long double __x, long double __y)
696		{ return __builtin_isgreater(__x, __y); }
697		#endif
698
699		template
700		constexpr typename
701		__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
702		&& __is_arithmetic<_Up>::__value), bool>::__type
703		isgreater(_Tp __x, _Up __y)
704		{
705		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
706		return __builtin_isgreater(__type(__x), __type(__y));
707		}
708
709		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
710		constexpr bool
711		isgreaterequal(float __x, float __y)
712		{ return __builtin_isgreaterequal(__x, __y); }
713
714		constexpr bool
715		isgreaterequal(double __x, double __y)
716		{ return __builtin_isgreaterequal(__x, __y); }
717
718		constexpr bool
719		isgreaterequal(long double __x, long double __y)
720		{ return __builtin_isgreaterequal(__x, __y); }
721		#endif
722
723		template
724		constexpr typename
725		__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
726		&& __is_arithmetic<_Up>::__value), bool>::__type
727		isgreaterequal(_Tp __x, _Up __y)
728		{
729		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
730		return __builtin_isgreaterequal(__type(__x), __type(__y));
731		}
732
733		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
734		constexpr bool
735		isless(float __x, float __y)
736		{ return __builtin_isless(__x, __y); }
737
738		constexpr bool
739		isless(double __x, double __y)
740		{ return __builtin_isless(__x, __y); }
741
742		constexpr bool
743		isless(long double __x, long double __y)
744		{ return __builtin_isless(__x, __y); }
745		#endif
746
747		template
748		constexpr typename
749		__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
750		&& __is_arithmetic<_Up>::__value), bool>::__type
751		isless(_Tp __x, _Up __y)
752		{
753		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
754		return __builtin_isless(__type(__x), __type(__y));
755		}
756
757		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
758		constexpr bool
759		islessequal(float __x, float __y)
760		{ return __builtin_islessequal(__x, __y); }
761
762		constexpr bool
763		islessequal(double __x, double __y)
764		{ return __builtin_islessequal(__x, __y); }
765
766		constexpr bool
767		islessequal(long double __x, long double __y)
768		{ return __builtin_islessequal(__x, __y); }
769		#endif
770
771		template
772		constexpr typename
773		__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
774		&& __is_arithmetic<_Up>::__value), bool>::__type
775		islessequal(_Tp __x, _Up __y)
776		{
777		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
778		return __builtin_islessequal(__type(__x), __type(__y));
779		}
780
781		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
782		constexpr bool
783		islessgreater(float __x, float __y)
784		{ return __builtin_islessgreater(__x, __y); }
785
786		constexpr bool
787		islessgreater(double __x, double __y)
788		{ return __builtin_islessgreater(__x, __y); }
789
790		constexpr bool
791		islessgreater(long double __x, long double __y)
792		{ return __builtin_islessgreater(__x, __y); }
793		#endif
794
795		template
796		constexpr typename
797		__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
798		&& __is_arithmetic<_Up>::__value), bool>::__type
799		islessgreater(_Tp __x, _Up __y)
800		{
801		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
802		return __builtin_islessgreater(__type(__x), __type(__y));
803		}
804
805		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
806		constexpr bool
807		isunordered(float __x, float __y)
808		{ return __builtin_isunordered(__x, __y); }
809
810		constexpr bool
811		isunordered(double __x, double __y)
812		{ return __builtin_isunordered(__x, __y); }
813
814		constexpr bool
815		isunordered(long double __x, long double __y)
816		{ return __builtin_isunordered(__x, __y); }
817		#endif
818
819		template
820		constexpr typename
821		__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
822		&& __is_arithmetic<_Up>::__value), bool>::__type
823		isunordered(_Tp __x, _Up __y)
824		{
825		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
826		return __builtin_isunordered(__type(__x), __type(__y));
827		}
828
829		#else
830
831		template
832		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
833		int>::__type
834		fpclassify(_Tp __f)
835		{
836		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
837		return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
838		FP_SUBNORMAL, FP_ZERO, __type(__f));
839		}
840
841		template
842		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
843		int>::__type
844		isfinite(_Tp __f)
845		{
846		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
847		return __builtin_isfinite(__type(__f));
848		}
849
850		template
851		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
852		int>::__type
853		isinf(_Tp __f)
854		{
855		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
856		return __builtin_isinf(__type(__f));
857		}
858
859		template
860		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
861		int>::__type
862		isnan(_Tp __f)
863		{
864		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
865		return __builtin_isnan(__type(__f));
866		}
867
868		template
869		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
870		int>::__type
871		isnormal(_Tp __f)
872		{
873		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
874		return __builtin_isnormal(__type(__f));
875		}
876
877		template
878		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
879		int>::__type
880		signbit(_Tp __f)
881		{
882		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
883		return sizeof(__type) == sizeof(float)
884		? __builtin_signbitf(__type(__f))
885		: sizeof(__type) == sizeof(double)
886		? __builtin_signbit(__type(__f))
887		: __builtin_signbitl(__type(__f));
888		}
889
890		template
891		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
892		int>::__type
893		isgreater(_Tp __f1, _Tp __f2)
894		{
895		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
896		return __builtin_isgreater(__type(__f1), __type(__f2));
897		}
898
899		template
900		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
901		int>::__type
902		isgreaterequal(_Tp __f1, _Tp __f2)
903		{
904		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
905		return __builtin_isgreaterequal(__type(__f1), __type(__f2));
906		}
907
908		template
909		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
910		int>::__type
911		isless(_Tp __f1, _Tp __f2)
912		{
913		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
914		return __builtin_isless(__type(__f1), __type(__f2));
915		}
916
917		template
918		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
919		int>::__type
920		islessequal(_Tp __f1, _Tp __f2)
921		{
922		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
923		return __builtin_islessequal(__type(__f1), __type(__f2));
924		}
925
926		template
927		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
928		int>::__type
929		islessgreater(_Tp __f1, _Tp __f2)
930		{
931		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
932		return __builtin_islessgreater(__type(__f1), __type(__f2));
933		}
934
935		template
936		inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
937		int>::__type
938		isunordered(_Tp __f1, _Tp __f2)
939		{
940		typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
941		return __builtin_isunordered(__type(__f1), __type(__f2));
942		}
943
944		#endif
945
946		_GLIBCXX_END_NAMESPACE_VERSION
947		} // namespace
948
949		#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
950		#endif
951
952		#if __cplusplus >= 201103L
953
954		#ifdef _GLIBCXX_USE_C99_MATH_TR1
955
956		#undef acosh
957		#undef acoshf
958		#undef acoshl
959		#undef asinh
960		#undef asinhf
961		#undef asinhl
962		#undef atanh
963		#undef atanhf
964		#undef atanhl
965		#undef cbrt
966		#undef cbrtf
967		#undef cbrtl
968		#undef copysign
969		#undef copysignf
970		#undef copysignl
971		#undef erf
972		#undef erff
973		#undef erfl
974		#undef erfc
975		#undef erfcf
976		#undef erfcl
977		#undef exp2
978		#undef exp2f
979		#undef exp2l
980		#undef expm1
981		#undef expm1f
982		#undef expm1l
983		#undef fdim
984		#undef fdimf
985		#undef fdiml
986		#undef fma
987		#undef fmaf
988		#undef fmal
989		#undef fmax
990		#undef fmaxf
991		#undef fmaxl
992		#undef fmin
993		#undef fminf
994		#undef fminl
995		#undef hypot
996		#undef hypotf
997		#undef hypotl
998		#undef ilogb
999		#undef ilogbf
1000		#undef ilogbl
1001		#undef lgamma
1002		#undef lgammaf
1003		#undef lgammal
1004		#undef llrint
1005		#undef llrintf
1006		#undef llrintl
1007		#undef llround
1008		#undef llroundf
1009		#undef llroundl
1010		#undef log1p
1011		#undef log1pf
1012		#undef log1pl
1013		#undef log2
1014		#undef log2f
1015		#undef log2l
1016		#undef logb
1017		#undef logbf
1018		#undef logbl
1019		#undef lrint
1020		#undef lrintf
1021		#undef lrintl
1022		#undef lround
1023		#undef lroundf
1024		#undef lroundl
1025		#undef nan
1026		#undef nanf
1027		#undef nanl
1028		#undef nearbyint
1029		#undef nearbyintf
1030		#undef nearbyintl
1031		#undef nextafter
1032		#undef nextafterf
1033		#undef nextafterl
1034		#undef nexttoward
1035		#undef nexttowardf
1036		#undef nexttowardl
1037		#undef remainder
1038		#undef remainderf
1039		#undef remainderl
1040		#undef remquo
1041		#undef remquof
1042		#undef remquol
1043		#undef rint
1044		#undef rintf
1045		#undef rintl
1046		#undef round
1047		#undef roundf
1048		#undef roundl
1049		#undef scalbln
1050		#undef scalblnf
1051		#undef scalblnl
1052		#undef scalbn
1053		#undef scalbnf
1054		#undef scalbnl
1055		#undef tgamma
1056		#undef tgammaf
1057		#undef tgammal
1058		#undef trunc
1059		#undef truncf
1060		#undef truncl
1061
1062		namespace std _GLIBCXX_VISIBILITY(default)
1063		{
1064		_GLIBCXX_BEGIN_NAMESPACE_VERSION
1065
1066		// types
1067		using ::double_t;
1068		using ::float_t;
1069
1070		// functions
1071		using ::acosh;
1072		using ::acoshf;
1073		using ::acoshl;
1074
1075		using ::asinh;
1076		using ::asinhf;
1077		using ::asinhl;
1078
1079		using ::atanh;
1080		using ::atanhf;
1081		using ::atanhl;
1082
1083		using ::cbrt;
1084		using ::cbrtf;
1085		using ::cbrtl;
1086
1087		using ::copysign;
1088		using ::copysignf;
1089		using ::copysignl;
1090
1091		using ::erf;
1092		using ::erff;
1093		using ::erfl;
1094
1095		using ::erfc;
1096		using ::erfcf;
1097		using ::erfcl;
1098
1099		using ::exp2;
1100		using ::exp2f;
1101		using ::exp2l;
1102
1103		using ::expm1;
1104		using ::expm1f;
1105		using ::expm1l;
1106
1107		using ::fdim;
1108		using ::fdimf;
1109		using ::fdiml;
1110
1111		using ::fma;
1112		using ::fmaf;
1113		using ::fmal;
1114
1115		using ::fmax;
1116		using ::fmaxf;
1117		using ::fmaxl;
1118
1119		using ::fmin;
1120		using ::fminf;
1121		using ::fminl;
1122
1123		using ::hypot;
1124		using ::hypotf;
1125		using ::hypotl;
1126
1127		using ::ilogb;
1128		using ::ilogbf;
1129		using ::ilogbl;
1130
1131		using ::lgamma;
1132		using ::lgammaf;
1133		using ::lgammal;
1134
1135		using ::llrint;
1136		using ::llrintf;
1137		using ::llrintl;
1138
1139		using ::llround;
1140		using ::llroundf;
1141		using ::llroundl;
1142
1143		using ::log1p;
1144		using ::log1pf;
1145		using ::log1pl;
1146
1147		using ::log2;
1148		using ::log2f;
1149		using ::log2l;
1150
1151		using ::logb;
1152		using ::logbf;
1153		using ::logbl;
1154
1155		using ::lrint;
1156		using ::lrintf;
1157		using ::lrintl;
1158
1159		using ::lround;
1160		using ::lroundf;
1161		using ::lroundl;
1162
1163		using ::nan;
1164		using ::nanf;
1165		using ::nanl;
1166
1167		using ::nearbyint;
1168		using ::nearbyintf;
1169		using ::nearbyintl;
1170
1171		using ::nextafter;
1172		using ::nextafterf;
1173		using ::nextafterl;
1174
1175		using ::nexttoward;
1176		using ::nexttowardf;
1177		using ::nexttowardl;
1178
1179		using ::remainder;
1180		using ::remainderf;
1181		using ::remainderl;
1182
1183		using ::remquo;
1184		using ::remquof;
1185		using ::remquol;
1186
1187		using ::rint;
1188		using ::rintf;
1189		using ::rintl;
1190
1191		using ::round;
1192		using ::roundf;
1193		using ::roundl;
1194
1195		using ::scalbln;
1196		using ::scalblnf;
1197		using ::scalblnl;
1198
1199		using ::scalbn;
1200		using ::scalbnf;
1201		using ::scalbnl;
1202
1203		using ::tgamma;
1204		using ::tgammaf;
1205		using ::tgammal;
1206
1207		using ::trunc;
1208		using ::truncf;
1209		using ::truncl;
1210
1211		/// Additional overloads.
1212		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1213		constexpr float
1214		acosh(float __x)
1215		{ return __builtin_acoshf(__x); }
1216
1217		constexpr long double
1218		acosh(long double __x)
1219		{ return __builtin_acoshl(__x); }
1220		#endif
1221
1222		template
1223		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1224		double>::__type
1225		acosh(_Tp __x)
1226		{ return __builtin_acosh(__x); }
1227
1228		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1229		constexpr float
1230		asinh(float __x)
1231		{ return __builtin_asinhf(__x); }
1232
1233		constexpr long double
1234		asinh(long double __x)
1235		{ return __builtin_asinhl(__x); }
1236		#endif
1237
1238		template
1239		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1240		double>::__type
1241		asinh(_Tp __x)
1242		{ return __builtin_asinh(__x); }
1243
1244		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1245		constexpr float
1246		atanh(float __x)
1247		{ return __builtin_atanhf(__x); }
1248
1249		constexpr long double
1250		atanh(long double __x)
1251		{ return __builtin_atanhl(__x); }
1252		#endif
1253
1254		template
1255		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1256		double>::__type
1257		atanh(_Tp __x)
1258		{ return __builtin_atanh(__x); }
1259
1260		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1261		constexpr float
1262		cbrt(float __x)
1263		{ return __builtin_cbrtf(__x); }
1264
1265		constexpr long double
1266		cbrt(long double __x)
1267		{ return __builtin_cbrtl(__x); }
1268		#endif
1269
1270		template
1271		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1272		double>::__type
1273		cbrt(_Tp __x)
1274		{ return __builtin_cbrt(__x); }
1275
1276		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1277		constexpr float
1278		copysign(float __x, float __y)
1279		{ return __builtin_copysignf(__x, __y); }
1280
1281		constexpr long double
1282		copysign(long double __x, long double __y)
1283		{ return __builtin_copysignl(__x, __y); }
1284		#endif
1285
1286		template
1287		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1288		copysign(_Tp __x, _Up __y)
1289		{
1290		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1291		return copysign(__type(__x), __type(__y));
1292		}
1293
1294		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1295		constexpr float
1296		erf(float __x)
1297		{ return __builtin_erff(__x); }
1298
1299		constexpr long double
1300		erf(long double __x)
1301		{ return __builtin_erfl(__x); }
1302		#endif
1303
1304		template
1305		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1306		double>::__type
1307		erf(_Tp __x)
1308		{ return __builtin_erf(__x); }
1309
1310		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1311		constexpr float
1312		erfc(float __x)
1313		{ return __builtin_erfcf(__x); }
1314
1315		constexpr long double
1316		erfc(long double __x)
1317		{ return __builtin_erfcl(__x); }
1318		#endif
1319
1320		template
1321		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1322		double>::__type
1323		erfc(_Tp __x)
1324		{ return __builtin_erfc(__x); }
1325
1326		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1327		constexpr float
1328		exp2(float __x)
1329		{ return __builtin_exp2f(__x); }
1330
1331		constexpr long double
1332		exp2(long double __x)
1333		{ return __builtin_exp2l(__x); }
1334		#endif
1335
1336		template
1337		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1338		double>::__type
1339		exp2(_Tp __x)
1340		{ return __builtin_exp2(__x); }
1341
1342		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1343		constexpr float
1344		expm1(float __x)
1345		{ return __builtin_expm1f(__x); }
1346
1347		constexpr long double
1348		expm1(long double __x)
1349		{ return __builtin_expm1l(__x); }
1350		#endif
1351
1352		template
1353		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1354		double>::__type
1355		expm1(_Tp __x)
1356		{ return __builtin_expm1(__x); }
1357
1358		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1359		constexpr float
1360		fdim(float __x, float __y)
1361		{ return __builtin_fdimf(__x, __y); }
1362
1363		constexpr long double
1364		fdim(long double __x, long double __y)
1365		{ return __builtin_fdiml(__x, __y); }
1366		#endif
1367
1368		template
1369		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1370		fdim(_Tp __x, _Up __y)
1371		{
1372		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1373		return fdim(__type(__x), __type(__y));
1374		}
1375
1376		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1377		constexpr float
1378		fma(float __x, float __y, float __z)
1379		{ return __builtin_fmaf(__x, __y, __z); }
1380
1381		constexpr long double
1382		fma(long double __x, long double __y, long double __z)
1383		{ return __builtin_fmal(__x, __y, __z); }
1384		#endif
1385
1386		template
1387		constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1388		fma(_Tp __x, _Up __y, _Vp __z)
1389		{
1390		typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
1391		return fma(__type(__x), __type(__y), __type(__z));
1392		}
1393
1394		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1395		constexpr float
1396		fmax(float __x, float __y)
1397		{ return __builtin_fmaxf(__x, __y); }
1398
1399		constexpr long double
1400		fmax(long double __x, long double __y)
1401		{ return __builtin_fmaxl(__x, __y); }
1402		#endif
1403
1404		template
1405		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1406		fmax(_Tp __x, _Up __y)
1407		{
1408		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1409		return fmax(__type(__x), __type(__y));
1410		}
1411
1412		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1413		constexpr float
1414		fmin(float __x, float __y)
1415		{ return __builtin_fminf(__x, __y); }
1416
1417		constexpr long double
1418		fmin(long double __x, long double __y)
1419		{ return __builtin_fminl(__x, __y); }
1420		#endif
1421
1422		template
1423		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1424		fmin(_Tp __x, _Up __y)
1425		{
1426		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1427		return fmin(__type(__x), __type(__y));
1428		}
1429
1430		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1431		constexpr float
1432		hypot(float __x, float __y)
1433		{ return __builtin_hypotf(__x, __y); }
1434
1435		constexpr long double
1436		hypot(long double __x, long double __y)
1437		{ return __builtin_hypotl(__x, __y); }
1438		#endif
1439
1440		template
1441		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1442		hypot(_Tp __x, _Up __y)
1443		{
1444		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1445		return hypot(__type(__x), __type(__y));
1446		}
1447
1448		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1449		constexpr int
1450		ilogb(float __x)
1451		{ return __builtin_ilogbf(__x); }
1452
1453		constexpr int
1454		ilogb(long double __x)
1455		{ return __builtin_ilogbl(__x); }
1456		#endif
1457
1458		template
1459		constexpr
1460		typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1461		int>::__type
1462		ilogb(_Tp __x)
1463		{ return __builtin_ilogb(__x); }
1464
1465		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1466		constexpr float
1467		lgamma(float __x)
1468		{ return __builtin_lgammaf(__x); }
1469
1470		constexpr long double
1471		lgamma(long double __x)
1472		{ return __builtin_lgammal(__x); }
1473		#endif
1474
1475		template
1476		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1477		double>::__type
1478		lgamma(_Tp __x)
1479		{ return __builtin_lgamma(__x); }
1480
1481		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1482		constexpr long long
1483		llrint(float __x)
1484		{ return __builtin_llrintf(__x); }
1485
1486		constexpr long long
1487		llrint(long double __x)
1488		{ return __builtin_llrintl(__x); }
1489		#endif
1490
1491		template
1492		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1493		long long>::__type
1494		llrint(_Tp __x)
1495		{ return __builtin_llrint(__x); }
1496
1497		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1498		constexpr long long
1499		llround(float __x)
1500		{ return __builtin_llroundf(__x); }
1501
1502		constexpr long long
1503		llround(long double __x)
1504		{ return __builtin_llroundl(__x); }
1505		#endif
1506
1507		template
1508		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1509		long long>::__type
1510		llround(_Tp __x)
1511		{ return __builtin_llround(__x); }
1512
1513		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1514		constexpr float
1515		log1p(float __x)
1516		{ return __builtin_log1pf(__x); }
1517
1518		constexpr long double
1519		log1p(long double __x)
1520		{ return __builtin_log1pl(__x); }
1521		#endif
1522
1523		template
1524		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1525		double>::__type
1526		log1p(_Tp __x)
1527		{ return __builtin_log1p(__x); }
1528
1529		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1530		// DR 568.
1531		constexpr float
1532		log2(float __x)
1533		{ return __builtin_log2f(__x); }
1534
1535		constexpr long double
1536		log2(long double __x)
1537		{ return __builtin_log2l(__x); }
1538		#endif
1539
1540		template
1541		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1542		double>::__type
1543		log2(_Tp __x)
1544		{ return __builtin_log2(__x); }
1545
1546		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1547		constexpr float
1548		logb(float __x)
1549		{ return __builtin_logbf(__x); }
1550
1551		constexpr long double
1552		logb(long double __x)
1553		{ return __builtin_logbl(__x); }
1554		#endif
1555
1556		template
1557		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1558		double>::__type
1559		logb(_Tp __x)
1560		{ return __builtin_logb(__x); }
1561
1562		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1563		constexpr long
1564		lrint(float __x)
1565		{ return __builtin_lrintf(__x); }
1566
1567		constexpr long
1568		lrint(long double __x)
1569		{ return __builtin_lrintl(__x); }
1570		#endif
1571
1572		template
1573		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1574		long>::__type
1575		lrint(_Tp __x)
1576		{ return __builtin_lrint(__x); }
1577
1578		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1579		constexpr long
1580		lround(float __x)
1581		{ return __builtin_lroundf(__x); }
1582
1583		constexpr long
1584		lround(long double __x)
1585		{ return __builtin_lroundl(__x); }
1586		#endif
1587
1588		template
1589		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1590		long>::__type
1591		lround(_Tp __x)
1592		{ return __builtin_lround(__x); }
1593
1594		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1595		constexpr float
1596		nearbyint(float __x)
1597		{ return __builtin_nearbyintf(__x); }
1598
1599		constexpr long double
1600		nearbyint(long double __x)
1601		{ return __builtin_nearbyintl(__x); }
1602		#endif
1603
1604		template
1605		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1606		double>::__type
1607		nearbyint(_Tp __x)
1608		{ return __builtin_nearbyint(__x); }
1609
1610		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1611		constexpr float
1612		nextafter(float __x, float __y)
1613		{ return __builtin_nextafterf(__x, __y); }
1614
1615		constexpr long double
1616		nextafter(long double __x, long double __y)
1617		{ return __builtin_nextafterl(__x, __y); }
1618		#endif
1619
1620		template
1621		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1622		nextafter(_Tp __x, _Up __y)
1623		{
1624		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1625		return nextafter(__type(__x), __type(__y));
1626		}
1627
1628		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1629		constexpr float
1630		nexttoward(float __x, long double __y)
1631		{ return __builtin_nexttowardf(__x, __y); }
1632
1633		constexpr long double
1634		nexttoward(long double __x, long double __y)
1635		{ return __builtin_nexttowardl(__x, __y); }
1636		#endif
1637
1638		template
1639		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1640		double>::__type
1641		nexttoward(_Tp __x, long double __y)
1642		{ return __builtin_nexttoward(__x, __y); }
1643
1644		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1645		constexpr float
1646		remainder(float __x, float __y)
1647		{ return __builtin_remainderf(__x, __y); }
1648
1649		constexpr long double
1650		remainder(long double __x, long double __y)
1651		{ return __builtin_remainderl(__x, __y); }
1652		#endif
1653
1654		template
1655		constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1656		remainder(_Tp __x, _Up __y)
1657		{
1658		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1659		return remainder(__type(__x), __type(__y));
1660		}
1661
1662		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1663		inline float
1664		remquo(float __x, float __y, int* __pquo)
1665		{ return __builtin_remquof(__x, __y, __pquo); }
1666
1667		inline long double
1668		remquo(long double __x, long double __y, int* __pquo)
1669		{ return __builtin_remquol(__x, __y, __pquo); }
1670		#endif
1671
1672		template
1673		inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1674		remquo(_Tp __x, _Up __y, int* __pquo)
1675		{
1676		typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1677		return remquo(__type(__x), __type(__y), __pquo);
1678		}
1679
1680		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1681		constexpr float
1682		rint(float __x)
1683		{ return __builtin_rintf(__x); }
1684
1685		constexpr long double
1686		rint(long double __x)
1687		{ return __builtin_rintl(__x); }
1688		#endif
1689
1690		template
1691		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1692		double>::__type
1693		rint(_Tp __x)
1694		{ return __builtin_rint(__x); }
1695
1696		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1697		constexpr float
1698		round(float __x)
1699		{ return __builtin_roundf(__x); }
1700
1701		constexpr long double
1702		round(long double __x)
1703		{ return __builtin_roundl(__x); }
1704		#endif
1705
1706		template
1707		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1708		double>::__type
1709		round(_Tp __x)
1710		{ return __builtin_round(__x); }
1711
1712		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1713		constexpr float
1714		scalbln(float __x, long __ex)
1715		{ return __builtin_scalblnf(__x, __ex); }
1716
1717		constexpr long double
1718		scalbln(long double __x, long __ex)
1719		{ return __builtin_scalblnl(__x, __ex); }
1720		#endif
1721
1722		template
1723		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1724		double>::__type
1725		scalbln(_Tp __x, long __ex)
1726		{ return __builtin_scalbln(__x, __ex); }
1727
1728		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1729		constexpr float
1730		scalbn(float __x, int __ex)
1731		{ return __builtin_scalbnf(__x, __ex); }
1732
1733		constexpr long double
1734		scalbn(long double __x, int __ex)
1735		{ return __builtin_scalbnl(__x, __ex); }
1736		#endif
1737
1738		template
1739		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1740		double>::__type
1741		scalbn(_Tp __x, int __ex)
1742		{ return __builtin_scalbn(__x, __ex); }
1743
1744		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1745		constexpr float
1746		tgamma(float __x)
1747		{ return __builtin_tgammaf(__x); }
1748
1749		constexpr long double
1750		tgamma(long double __x)
1751		{ return __builtin_tgammal(__x); }
1752		#endif
1753
1754		template
1755		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1756		double>::__type
1757		tgamma(_Tp __x)
1758		{ return __builtin_tgamma(__x); }
1759
1760		#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
1761		constexpr float
1762		trunc(float __x)
1763		{ return __builtin_truncf(__x); }
1764
1765		constexpr long double
1766		trunc(long double __x)
1767		{ return __builtin_truncl(__x); }
1768		#endif
1769
1770		template
1771		constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1772		double>::__type
1773		trunc(_Tp __x)
1774		{ return __builtin_trunc(__x); }
1775
1776		_GLIBCXX_END_NAMESPACE_VERSION
1777		} // namespace
1778
1779		#endif // _GLIBCXX_USE_C99_MATH_TR1
1780
1781		#endif // C++11
1782
1783		#endif