[thirdparty/gcc.git] / libstdc++-v3 / include / c_std / cmath

// -*- C++ -*- C forwarding header.

// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
// 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 2, 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.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

/** @file include/cmath
 *  This is a Standard C++ Library file.  You should @c #include this file
 *  in your programs, rather than any of the "*.h" implementation files.
 *
 *  This is the C++ version of the Standard C Library header @c math.h,
 *  and its contents are (mostly) the same as that header, but are all
 *  contained in the namespace @c std (except for names which are defined
 *  as macros in C).
 */

//
// ISO C++ 14882: 26.5  C library
//

#ifndef _GLIBCXX_CMATH
#define _GLIBCXX_CMATH 1

#pragma GCC system_header

#include <bits/c++config.h>
#include <bits/cpp_type_traits.h>
#include <ext/type_traits.h>

#include <math.h>

// Get rid of those macros defined in <math.h> in lieu of real functions.
#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh

_GLIBCXX_BEGIN_NAMESPACE(std)

  // Forward declaration of a helper function.  This really should be
  // an `exported' forward declaration.
  template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);

  inline double
  abs(double __x)
  { return __builtin_fabs(__x); }

  inline float
  abs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  abs(long double __x)
  { return __builtin_fabsl(__x); }

  using ::acos;

  inline float
  acos(float __x)
  { return __builtin_acosf(__x); }

  inline long double
  acos(long double __x)
  { return __builtin_acosl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;

  inline float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline long double
  asin(long double __x)
  { return __builtin_asinl(__x); }

  template<typename _Tp>
  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
					 double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;

  inline float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline long double
  atan(long double __x)
  { return __builtin_atanl(__x); }

  template<typename _Tp>
  inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					 double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;

  inline float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }

  template<typename _Tp, typename _Up>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
    					   && __is_integer<_Up>::__value, 
					   double>::__type
    atan2(_Tp __y, _Up __x)
    { return __builtin_atan2(__y, __x); }

  using ::ceil;

  inline float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;

  inline float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline long double
  cos(long double __x)
  { return __builtin_cosl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;

  inline float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;

  inline float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline long double
  exp(long double __x)
  { return __builtin_expl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;

  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); }

  using ::floor;

  inline float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline long double
  floor(long double __x)
  { return __builtin_floorl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;

  inline float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }

  using ::frexp;

  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;

  inline float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
  ldexp(_Tp __x, int __exp)
  { return __builtin_ldexp(__x, __exp); }

  using ::log;

  inline float
  log(float __x)
  { return __builtin_logf(__x); }

  inline long double
  log(long double __x)
  { return __builtin_logl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;

  inline float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline long double
  log10(long double __x)
  { return __builtin_log10l(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    log10(_Tp __x)
    { return __builtin_log10(__x); }

  using ::modf;

  inline float
  modf(float __x, float* __iptr)
  { return __builtin_modff(__x, __iptr); }

  inline long double
  modf(long double __x, long double* __iptr)
  { return __builtin_modfl(__x, __iptr); }

  template<typename _Tp>
    inline _Tp
    __pow_helper(_Tp __x, int __n)
    {
      return __n < 0
        ? _Tp(1)/__cmath_power(__x, -__n)
        : __cmath_power(__x, __n);
    }

  using ::pow;

  inline float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }

  inline double
  pow(double __x, int __i)
  { return __builtin_powi(__x, __i); }

  inline float
  pow(float __x, int __n)
  { return __builtin_powif(__x, __n); }

  inline long double
  pow(long double __x, int __n)
  { return __builtin_powil(__x, __n); }

  using ::sin;

  inline float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline long double
  sin(long double __x)
  { return __builtin_sinl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;

  inline float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;

  inline float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;

  inline float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline long double
  tan(long double __x)
  { return __builtin_tanl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;

  inline float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
					   double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }

_GLIBCXX_END_NAMESPACE

#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
// These are possible macros imported from C99-land. For strict
// conformance, remove possible C99-injected names from the global
// namespace, and sequester them in the __gnu_cxx extension namespace.

_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)

  template<typename _Tp>
    inline int
    __capture_fpclassify(_Tp __f) { return fpclassify(__f); }

  template<typename _Tp>
    inline int
    __capture_isfinite(_Tp __f) { return isfinite(__f); }

  template<typename _Tp>
    inline int
    __capture_isinf(_Tp __f) { return isinf(__f); }

  template<typename _Tp>
    inline int
    __capture_isnan(_Tp __f) { return isnan(__f); }

  template<typename _Tp>
    inline int
    __capture_isnormal(_Tp __f) { return isnormal(__f); }

  template<typename _Tp>
    inline int
    __capture_signbit(_Tp __f) { return signbit(__f); }

  template<typename _Tp>
    inline int
    __capture_isgreater(_Tp __f1, _Tp __f2)
    { return isgreater(__f1, __f2); }

  template<typename _Tp>
    inline int
    __capture_isgreaterequal(_Tp __f1, _Tp __f2)
    { return isgreaterequal(__f1, __f2); }

  template<typename _Tp>
    inline int
    __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }

  template<typename _Tp>
    inline int
    __capture_islessequal(_Tp __f1, _Tp __f2)
    { return islessequal(__f1, __f2); }

  template<typename _Tp>
    inline int
    __capture_islessgreater(_Tp __f1, _Tp __f2)
    { return islessgreater(__f1, __f2); }

  template<typename _Tp>
    inline int
    __capture_isunordered(_Tp __f1, _Tp __f2)
    { return isunordered(__f1, __f2); }

_GLIBCXX_END_NAMESPACE

// Only undefine the C99 FP macros, if actually captured for namespace movement
#undef fpclassify
#undef isfinite
#undef isinf
#undef isnan
#undef isnormal
#undef signbit
#undef isgreater
#undef isgreaterequal
#undef isless
#undef islessequal
#undef islessgreater
#undef isunordered

_GLIBCXX_BEGIN_NAMESPACE(std)

  template<typename _Tp>
    inline int
    fpclassify(_Tp __f) { return ::__gnu_cxx::__capture_fpclassify(__f); }

  template<typename _Tp>
    inline int
    isfinite(_Tp __f) { return ::__gnu_cxx::__capture_isfinite(__f); }

  template<typename _Tp>
    inline int
    isinf(_Tp __f) { return ::__gnu_cxx::__capture_isinf(__f); }

  template<typename _Tp>
    inline int
    isnan(_Tp __f) { return ::__gnu_cxx::__capture_isnan(__f); }

  template<typename _Tp>
    inline int
    isnormal(_Tp __f) { return ::__gnu_cxx::__capture_isnormal(__f); }

  template<typename _Tp>
    inline int
    signbit(_Tp __f) { return ::__gnu_cxx::__capture_signbit(__f); }

  template<typename _Tp>
    inline int
    isgreater(_Tp __f1, _Tp __f2)
    { return ::__gnu_cxx::__capture_isgreater(__f1, __f2); }

  template<typename _Tp>
    inline int
    isgreaterequal(_Tp __f1, _Tp __f2)
    { return ::__gnu_cxx::__capture_isgreaterequal(__f1, __f2); }

  template<typename _Tp>
    inline int
    isless(_Tp __f1, _Tp __f2)
    { return ::__gnu_cxx::__capture_isless(__f1, __f2); }

  template<typename _Tp>
    inline int
    islessequal(_Tp __f1, _Tp __f2)
    { return ::__gnu_cxx::__capture_islessequal(__f1, __f2); }

  template<typename _Tp>
    inline int
    islessgreater(_Tp __f1, _Tp __f2)
    { return ::__gnu_cxx::__capture_islessgreater(__f1, __f2); }

  template<typename _Tp>
    inline int
    isunordered(_Tp __f1, _Tp __f2)
    { return ::__gnu_cxx::__capture_isunordered(__f1, __f2); }

_GLIBCXX_END_NAMESPACE

#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif

#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include <bits/cmath.tcc>
#endif

#endif
Commit	Line	Data
34ff0b99	1	// -- C++ -- C forwarding header.
22aef514	2
105c6331	3	// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
34ff0b99	4	// Free Software Foundation, Inc.
22aef514 BK	5	//
	6	// This file is part of the GNU ISO C++ Library. This library is free
	7	// software; you can redistribute it and/or modify it under the
	8	// terms of the GNU General Public License as published by the
	9	// Free Software Foundation; either version 2, or (at your option)
	10	// any later version.
	11
	12	// This library is distributed in the hope that it will be useful,
	13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	// GNU General Public License for more details.
	16
	17	// You should have received a copy of the GNU General Public License along
	18	// with this library; see the file COPYING. If not, write to the Free
83f51799	19	// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
22aef514 BK	20	// USA.
	21
	22	// As a special exception, you may use this file as part of a free software
	23	// library without restriction. Specifically, if other files instantiate
	24	// templates or use macros or inline functions from this file, or you compile
	25	// this file and link it with other files to produce an executable, this
	26	// file does not by itself cause the resulting executable to be covered by
	27	// the GNU General Public License. This exception does not however
	28	// invalidate any other reasons why the executable file might be covered by
	29	// the GNU General Public License.
	30
143c27b0	31	/** @file include/cmath
ffe94f83 PE	32	* This is a Standard C++ Library file. You should @c #include this file
	33	* in your programs, rather than any of the "*.h" implementation files.
	34	*
	35	* This is the C++ version of the Standard C Library header @c math.h,
	36	* and its contents are (mostly) the same as that header, but are all
097588e4 PC	37	* contained in the namespace @c std (except for names which are defined
097588e4 PC	38	* as macros in C).
ffe94f83 PE	39	*/
ffe94f83 PE	40
143c27b0 BK	41	//
	42	// ISO C++ 14882: 26.5 C library
	43	//
	44
1143680e SE	45	#ifndef _GLIBCXX_CMATH
1143680e SE	46	#define _GLIBCXX_CMATH 1
34ff0b99 BK	47
34ff0b99 BK	48	#pragma GCC system_header
22aef514	49
98e6e789	50	#include <bits/c++config.h>
cdc958d8	51	#include <bits/cpp_type_traits.h>
105c6331	52	#include <ext/type_traits.h>
4e588ec9	53
c0dae541	54	#include <math.h>
22aef514	55
8089616e BK	56	// Get rid of those macros defined in <math.h> in lieu of real functions.
	57	#undef abs
	58	#undef div
	59	#undef acos
	60	#undef asin
	61	#undef atan
	62	#undef atan2
	63	#undef ceil
	64	#undef cos
	65	#undef cosh
	66	#undef exp
	67	#undef fabs
	68	#undef floor
	69	#undef fmod
	70	#undef frexp
	71	#undef ldexp
	72	#undef log
	73	#undef log10
	74	#undef modf
	75	#undef pow
	76	#undef sin
	77	#undef sinh
4200d6fe	78	#undef sqrt
8089616e BK	79	#undef tan
	80	#undef tanh
	81
3cbc7af0	82	_GLIBCXX_BEGIN_NAMESPACE(std)
b39d0359	83
98e6e789 BK	84	// Forward declaration of a helper function. This really should be
	85	// an `exported' forward declaration.
	86	template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
	87
4e588ec9 GDR	88	inline double
	89	abs(double __x)
	90	{ return __builtin_fabs(__x); }
	91
d52e4867 RS	92	inline float
	93	abs(float __x)
	94	{ return __builtin_fabsf(__x); }
	95
4e588ec9 GDR	96	inline long double
	97	abs(long double __x)
	98	{ return __builtin_fabsl(__x); }
	99
de96ac46	100	using ::acos;
c85dfef7 RS	101
	102	inline float
	103	acos(float __x)
	104	{ return __builtin_acosf(__x); }
	105
	106	inline long double
	107	acos(long double __x)
	108	{ return __builtin_acosl(__x); }
4e588ec9	109
cdc958d8	110	template<typename _Tp>
105c6331 BK	111	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	112	double>::__type
cdc958d8	113	acos(_Tp __x)
105c6331	114	{ return __builtin_acos(__x); }
7dd8177f	115
d52e4867 RS	116	using ::asin;
d52e4867 RS	117
7dd8177f	118	inline float
c85dfef7 RS	119	asin(float __x)
c85dfef7 RS	120	{ return __builtin_asinf(__x); }
22aef514	121
7dd8177f	122	inline long double
c85dfef7 RS	123	asin(long double __x)
c85dfef7 RS	124	{ return __builtin_asinl(__x); }
4e588ec9	125
cdc958d8	126	template<typename _Tp>
105c6331 BK	127	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	128	double>::__type
cdc958d8	129	asin(_Tp __x)
c85dfef7	130	{ return __builtin_asin(__x); }
cdc958d8	131
d52e4867 RS	132	using ::atan;
d52e4867 RS	133
7dd8177f	134	inline float
c85dfef7 RS	135	atan(float __x)
c85dfef7 RS	136	{ return __builtin_atanf(__x); }
22aef514	137
7dd8177f	138	inline long double
c85dfef7 RS	139	atan(long double __x)
c85dfef7 RS	140	{ return __builtin_atanl(__x); }
4e588ec9	141
cdc958d8	142	template<typename _Tp>
105c6331 BK	143	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	144	double>::__type
cdc958d8	145	atan(_Tp __x)
c85dfef7	146	{ return __builtin_atan(__x); }
7dd8177f	147
d52e4867 RS	148	using ::atan2;
d52e4867 RS	149
7dd8177f	150	inline float
98e6e789	151	atan2(float __y, float __x)
c85dfef7	152	{ return __builtin_atan2f(__y, __x); }
22aef514	153
7dd8177f	154	inline long double
c85dfef7 RS	155	atan2(long double __y, long double __x)
c85dfef7 RS	156	{ return __builtin_atan2l(__y, __x); }
4e588ec9	157
cdc958d8	158	template<typename _Tp, typename _Up>
105c6331 BK	159	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
	160	&& __is_integer<_Up>::__value,
	161	double>::__type
c85dfef7 RS	162	atan2(_Tp __y, _Up __x)
c85dfef7 RS	163	{ return __builtin_atan2(__y, __x); }
cdc958d8	164
d52e4867 RS	165	using ::ceil;
d52e4867 RS	166
7dd8177f	167	inline float
c85dfef7 RS	168	ceil(float __x)
c85dfef7 RS	169	{ return __builtin_ceilf(__x); }
22aef514	170
7dd8177f	171	inline long double
c85dfef7 RS	172	ceil(long double __x)
c85dfef7 RS	173	{ return __builtin_ceill(__x); }
22aef514	174
cdc958d8	175	template<typename _Tp>
105c6331 BK	176	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	177	double>::__type
cdc958d8	178	ceil(_Tp __x)
c85dfef7	179	{ return __builtin_ceil(__x); }
7dd8177f	180
d52e4867 RS	181	using ::cos;
d52e4867 RS	182
4e588ec9 GDR	183	inline float
	184	cos(float __x)
	185	{ return __builtin_cosf(__x); }
	186
4e588ec9 GDR	187	inline long double
	188	cos(long double __x)
	189	{ return __builtin_cosl(__x); }
	190
cdc958d8	191	template<typename _Tp>
105c6331 BK	192	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	193	double>::__type
cdc958d8 GDR	194	cos(_Tp __x)
	195	{ return __builtin_cos(__x); }
	196
d52e4867 RS	197	using ::cosh;
d52e4867 RS	198
7dd8177f	199	inline float
c85dfef7 RS	200	cosh(float __x)
c85dfef7 RS	201	{ return __builtin_coshf(__x); }
22aef514	202
7dd8177f	203	inline long double
c85dfef7 RS	204	cosh(long double __x)
c85dfef7 RS	205	{ return __builtin_coshl(__x); }
4e588ec9	206
cdc958d8	207	template<typename _Tp>
105c6331 BK	208	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	209	double>::__type
cdc958d8	210	cosh(_Tp __x)
c85dfef7	211	{ return __builtin_cosh(__x); }
cdc958d8	212
d52e4867 RS	213	using ::exp;
d52e4867 RS	214
7dd8177f	215	inline float
c85dfef7 RS	216	exp(float __x)
c85dfef7 RS	217	{ return __builtin_expf(__x); }
22aef514	218
7dd8177f	219	inline long double
c85dfef7 RS	220	exp(long double __x)
c85dfef7 RS	221	{ return __builtin_expl(__x); }
22aef514	222
cdc958d8	223	template<typename _Tp>
105c6331 BK	224	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	225	double>::__type
cdc958d8	226	exp(_Tp __x)
c85dfef7	227	{ return __builtin_exp(__x); }
7dd8177f	228
d52e4867 RS	229	using ::fabs;
d52e4867 RS	230
4e588ec9 GDR	231	inline float
	232	fabs(float __x)
	233	{ return __builtin_fabsf(__x); }
	234
4e588ec9 GDR	235	inline long double
	236	fabs(long double __x)
	237	{ return __builtin_fabsl(__x); }
	238
cdc958d8	239	template<typename _Tp>
105c6331 BK	240	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	241	double>::__type
cdc958d8 GDR	242	fabs(_Tp __x)
	243	{ return __builtin_fabs(__x); }
	244
d52e4867 RS	245	using ::floor;
d52e4867 RS	246
7dd8177f	247	inline float
c85dfef7 RS	248	floor(float __x)
c85dfef7 RS	249	{ return __builtin_floorf(__x); }
22aef514	250
7dd8177f	251	inline long double
c85dfef7 RS	252	floor(long double __x)
c85dfef7 RS	253	{ return __builtin_floorl(__x); }
4e588ec9	254
cdc958d8	255	template<typename _Tp>
105c6331 BK	256	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	257	double>::__type
cdc958d8	258	floor(_Tp __x)
c85dfef7	259	{ return __builtin_floor(__x); }
7dd8177f	260
d52e4867 RS	261	using ::fmod;
d52e4867 RS	262
7dd8177f	263	inline float
98e6e789	264	fmod(float __x, float __y)
c85dfef7	265	{ return __builtin_fmodf(__x, __y); }
22aef514	266
7dd8177f	267	inline long double
c85dfef7 RS	268	fmod(long double __x, long double __y)
c85dfef7 RS	269	{ return __builtin_fmodl(__x, __y); }
4e588ec9	270
d52e4867 RS	271	using ::frexp;
d52e4867 RS	272
7dd8177f	273	inline float
c85dfef7 RS	274	frexp(float __x, int* __exp)
c85dfef7 RS	275	{ return __builtin_frexpf(__x, __exp); }
22aef514	276
7dd8177f	277	inline long double
c85dfef7 RS	278	frexp(long double __x, int* __exp)
c85dfef7 RS	279	{ return __builtin_frexpl(__x, __exp); }
4e588ec9	280
cdc958d8	281	template<typename _Tp>
105c6331 BK	282	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	283	double>::__type
cdc958d8	284	frexp(_Tp __x, int* __exp)
c85dfef7	285	{ return __builtin_frexp(__x, __exp); }
7dd8177f	286
d52e4867 RS	287	using ::ldexp;
d52e4867 RS	288
7dd8177f	289	inline float
98e6e789	290	ldexp(float __x, int __exp)
c85dfef7	291	{ return __builtin_ldexpf(__x, __exp); }
22aef514	292
7dd8177f	293	inline long double
c85dfef7 RS	294	ldexp(long double __x, int __exp)
c85dfef7 RS	295	{ return __builtin_ldexpl(__x, __exp); }
4e588ec9	296
cdc958d8	297	template<typename _Tp>
105c6331 BK	298	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	299	double>::__type
cdc958d8	300	ldexp(_Tp __x, int __exp)
c85dfef7	301	{ return __builtin_ldexp(__x, __exp); }
cdc958d8	302
d52e4867 RS	303	using ::log;
d52e4867 RS	304
7dd8177f	305	inline float
c85dfef7 RS	306	log(float __x)
c85dfef7 RS	307	{ return __builtin_logf(__x); }
22aef514	308
7dd8177f	309	inline long double
c85dfef7 RS	310	log(long double __x)
c85dfef7 RS	311	{ return __builtin_logl(__x); }
4e588ec9	312
cdc958d8	313	template<typename _Tp>
105c6331 BK	314	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	315	double>::__type
cdc958d8	316	log(_Tp __x)
c85dfef7	317	{ return __builtin_log(__x); }
7dd8177f	318
d52e4867 RS	319	using ::log10;
d52e4867 RS	320
7dd8177f	321	inline float
c85dfef7 RS	322	log10(float __x)
c85dfef7 RS	323	{ return __builtin_log10f(__x); }
22aef514	324
7dd8177f	325	inline long double
c85dfef7 RS	326	log10(long double __x)
c85dfef7 RS	327	{ return __builtin_log10l(__x); }
4e588ec9	328
cdc958d8	329	template<typename _Tp>
105c6331 BK	330	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	331	double>::__type
cdc958d8	332	log10(_Tp __x)
c85dfef7	333	{ return __builtin_log10(__x); }
7dd8177f	334
d52e4867 RS	335	using ::modf;
d52e4867 RS	336
7dd8177f	337	inline float
98e6e789	338	modf(float __x, float* __iptr)
c85dfef7 RS	339	{ return __builtin_modff(__x, __iptr); }
c85dfef7 RS	340
7dd8177f	341	inline long double
c85dfef7 RS	342	modf(long double __x, long double* __iptr)
c85dfef7 RS	343	{ return __builtin_modfl(__x, __iptr); }
4e588ec9	344
98e6e789 BK	345	template<typename _Tp>
	346	inline _Tp
	347	__pow_helper(_Tp __x, int __n)
	348	{
	349	return __n < 0
	350	? _Tp(1)/__cmath_power(__x, -__n)
	351	: __cmath_power(__x, __n);
	352	}
d52e4867 RS	353
	354	using ::pow;
	355
7dd8177f	356	inline float
98e6e789	357	pow(float __x, float __y)
c85dfef7	358	{ return __builtin_powf(__x, __y); }
22aef514	359
7dd8177f	360	inline long double
c85dfef7 RS	361	pow(long double __x, long double __y)
c85dfef7 RS	362	{ return __builtin_powl(__x, __y); }
22aef514	363
7dd8177f	364	inline double
98e6e789	365	pow(double __x, int __i)
ae63a1cc	366	{ return __builtin_powi(__x, __i); }
22aef514	367
7dd8177f	368	inline float
d52e4867	369	pow(float __x, int __n)
ae63a1cc	370	{ return __builtin_powif(__x, __n); }
d52e4867	371
7dd8177f	372	inline long double
4e588ec9	373	pow(long double __x, int __n)
ae63a1cc	374	{ return __builtin_powil(__x, __n); }
22aef514	375
d52e4867 RS	376	using ::sin;
d52e4867 RS	377
4e588ec9 GDR	378	inline float
	379	sin(float __x)
	380	{ return __builtin_sinf(__x); }
22aef514	381
4e588ec9 GDR	382	inline long double
	383	sin(long double __x)
	384	{ return __builtin_sinl(__x); }
22aef514	385
cdc958d8	386	template<typename _Tp>
105c6331 BK	387	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	388	double>::__type
cdc958d8 GDR	389	sin(_Tp __x)
	390	{ return __builtin_sin(__x); }
	391
d52e4867 RS	392	using ::sinh;
d52e4867 RS	393
7dd8177f	394	inline float
c85dfef7 RS	395	sinh(float __x)
c85dfef7 RS	396	{ return __builtin_sinhf(__x); }
22aef514	397
7dd8177f	398	inline long double
c85dfef7 RS	399	sinh(long double __x)
c85dfef7 RS	400	{ return __builtin_sinhl(__x); }
22aef514	401
cdc958d8	402	template<typename _Tp>
105c6331 BK	403	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	404	double>::__type
cdc958d8	405	sinh(_Tp __x)
c85dfef7	406	{ return __builtin_sinh(__x); }
7dd8177f	407
d52e4867 RS	408	using ::sqrt;
d52e4867 RS	409
4e588ec9 GDR	410	inline float
	411	sqrt(float __x)
	412	{ return __builtin_sqrtf(__x); }
22aef514	413
4e588ec9 GDR	414	inline long double
	415	sqrt(long double __x)
	416	{ return __builtin_sqrtl(__x); }
22aef514	417
cdc958d8	418	template<typename _Tp>
105c6331 BK	419	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	420	double>::__type
cdc958d8 GDR	421	sqrt(_Tp __x)
cdc958d8 GDR	422	{ return __builtin_sqrt(__x); }
7dd8177f	423
d52e4867 RS	424	using ::tan;
d52e4867 RS	425
7dd8177f	426	inline float
c85dfef7 RS	427	tan(float __x)
c85dfef7 RS	428	{ return __builtin_tanf(__x); }
22aef514	429
7dd8177f	430	inline long double
c85dfef7 RS	431	tan(long double __x)
c85dfef7 RS	432	{ return __builtin_tanl(__x); }
22aef514	433
cdc958d8	434	template<typename _Tp>
105c6331 BK	435	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	436	double>::__type
cdc958d8	437	tan(_Tp __x)
c85dfef7	438	{ return __builtin_tan(__x); }
7dd8177f	439
d52e4867 RS	440	using ::tanh;
d52e4867 RS	441
7dd8177f	442	inline float
c85dfef7 RS	443	tanh(float __x)
c85dfef7 RS	444	{ return __builtin_tanhf(__x); }
22aef514	445
7dd8177f	446	inline long double
c85dfef7 RS	447	tanh(long double __x)
c85dfef7 RS	448	{ return __builtin_tanhl(__x); }
cdc958d8 GDR	449
cdc958d8 GDR	450	template<typename _Tp>
105c6331 BK	451	inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
105c6331 BK	452	double>::__type
cdc958d8	453	tanh(_Tp __x)
c85dfef7	454	{ return __builtin_tanh(__x); }
3cbc7af0 BK	455
3cbc7af0 BK	456	_GLIBCXX_END_NAMESPACE
22aef514	457
517da0ce	458	#if _GLIBCXX_USE_C99_MATH
3d7c150e	459	#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
7cda84dc	460	// These are possible macros imported from C99-land. For strict
3702c634	461	// conformance, remove possible C99-injected names from the global
7dd8177f	462	// namespace, and sequester them in the __gnu_cxx extension namespace.
3cbc7af0 BK	463
	464	_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
	465
7cda84dc	466	template<typename _Tp>
d42a11e1	467	inline int
7cda84dc BK	468	__capture_fpclassify(_Tp __f) { return fpclassify(__f); }
	469
	470	template<typename _Tp>
d42a11e1	471	inline int
7cda84dc BK	472	__capture_isfinite(_Tp __f) { return isfinite(__f); }
	473
	474	template<typename _Tp>
d42a11e1	475	inline int
7cda84dc BK	476	__capture_isinf(_Tp __f) { return isinf(__f); }
	477
	478	template<typename _Tp>
d42a11e1	479	inline int
7cda84dc BK	480	__capture_isnan(_Tp __f) { return isnan(__f); }
	481
	482	template<typename _Tp>
d42a11e1	483	inline int
7cda84dc BK	484	__capture_isnormal(_Tp __f) { return isnormal(__f); }
	485
	486	template<typename _Tp>
d42a11e1	487	inline int
7cda84dc BK	488	__capture_signbit(_Tp __f) { return signbit(__f); }
	489
	490	template<typename _Tp>
d42a11e1	491	inline int
3702c634 GDR	492	__capture_isgreater(_Tp __f1, _Tp __f2)
3702c634 GDR	493	{ return isgreater(__f1, __f2); }
7cda84dc	494
3702c634	495	template<typename _Tp>
d42a11e1 BK	496	inline int
	497	__capture_isgreaterequal(_Tp __f1, _Tp __f2)
	498	{ return isgreaterequal(__f1, __f2); }
7cda84dc	499
3702c634	500	template<typename _Tp>
4eafe882	501	inline int
d42a11e1	502	__capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
7cda84dc	503
3702c634	504	template<typename _Tp>
d42a11e1 BK	505	inline int
	506	__capture_islessequal(_Tp __f1, _Tp __f2)
	507	{ return islessequal(__f1, __f2); }
7cda84dc	508
3702c634	509	template<typename _Tp>
d42a11e1 BK	510	inline int
	511	__capture_islessgreater(_Tp __f1, _Tp __f2)
	512	{ return islessgreater(__f1, __f2); }
7cda84dc	513
3702c634	514	template<typename _Tp>
d42a11e1 BK	515	inline int
	516	__capture_isunordered(_Tp __f1, _Tp __f2)
	517	{ return isunordered(__f1, __f2); }
3cbc7af0 BK	518
3cbc7af0 BK	519	_GLIBCXX_END_NAMESPACE
7cda84dc	520
c04ec67e	521	// Only undefine the C99 FP macros, if actually captured for namespace movement
7cda84dc BK	522	#undef fpclassify
	523	#undef isfinite
	524	#undef isinf
	525	#undef isnan
	526	#undef isnormal
	527	#undef signbit
	528	#undef isgreater
	529	#undef isgreaterequal
	530	#undef isless
	531	#undef islessequal
	532	#undef islessgreater
	533	#undef isunordered
	534
3cbc7af0 BK	535	_GLIBCXX_BEGIN_NAMESPACE(std)
3cbc7af0 BK	536
7cda84dc	537	template<typename _Tp>
d42a11e1	538	inline int
3cbc7af0	539	fpclassify(_Tp __f) { return ::__gnu_cxx::__capture_fpclassify(__f); }
7cda84dc BK	540
7cda84dc BK	541	template<typename _Tp>
d42a11e1	542	inline int
3cbc7af0	543	isfinite(_Tp __f) { return ::__gnu_cxx::__capture_isfinite(__f); }
7cda84dc BK	544
7cda84dc BK	545	template<typename _Tp>
d42a11e1	546	inline int
3cbc7af0	547	isinf(_Tp __f) { return ::__gnu_cxx::__capture_isinf(__f); }
7cda84dc BK	548
7cda84dc BK	549	template<typename _Tp>
d42a11e1	550	inline int
3cbc7af0	551	isnan(_Tp __f) { return ::__gnu_cxx::__capture_isnan(__f); }
7cda84dc BK	552
7cda84dc BK	553	template<typename _Tp>
d42a11e1	554	inline int
3cbc7af0	555	isnormal(_Tp __f) { return ::__gnu_cxx::__capture_isnormal(__f); }
7cda84dc BK	556
7cda84dc BK	557	template<typename _Tp>
d42a11e1	558	inline int
3cbc7af0	559	signbit(_Tp __f) { return ::__gnu_cxx::__capture_signbit(__f); }
7cda84dc BK	560
7cda84dc BK	561	template<typename _Tp>
d42a11e1	562	inline int
3a2794ab	563	isgreater(_Tp __f1, _Tp __f2)
3cbc7af0	564	{ return ::__gnu_cxx::__capture_isgreater(__f1, __f2); }
7cda84dc BK	565
7cda84dc BK	566	template<typename _Tp>
d42a11e1	567	inline int
7dd8177f	568	isgreaterequal(_Tp __f1, _Tp __f2)
3cbc7af0	569	{ return ::__gnu_cxx::__capture_isgreaterequal(__f1, __f2); }
7cda84dc BK	570
7cda84dc BK	571	template<typename _Tp>
d42a11e1	572	inline int
3a2794ab	573	isless(_Tp __f1, _Tp __f2)
3cbc7af0	574	{ return ::__gnu_cxx::__capture_isless(__f1, __f2); }
7cda84dc BK	575
7cda84dc BK	576	template<typename _Tp>
d42a11e1	577	inline int
7dd8177f	578	islessequal(_Tp __f1, _Tp __f2)
3cbc7af0	579	{ return ::__gnu_cxx::__capture_islessequal(__f1, __f2); }
7cda84dc BK	580
7cda84dc BK	581	template<typename _Tp>
d42a11e1	582	inline int
7dd8177f	583	islessgreater(_Tp __f1, _Tp __f2)
3cbc7af0	584	{ return ::__gnu_cxx::__capture_islessgreater(__f1, __f2); }
7cda84dc BK	585
7cda84dc BK	586	template<typename _Tp>
d42a11e1	587	inline int
7dd8177f	588	isunordered(_Tp __f1, _Tp __f2)
3cbc7af0 BK	589	{ return ::__gnu_cxx::__capture_isunordered(__f1, __f2); }
	590
	591	_GLIBCXX_END_NAMESPACE
	592
3d7c150e	593	#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
7cda84dc	594	#endif
7dd8177f	595
5f697f7a BK	596	#ifndef _GLIBCXX_EXPORT_TEMPLATE
5f697f7a BK	597	# include <bits/cmath.tcc>
607642b6	598	#endif
22aef514	599
98e6e789	600	#endif