diff options
Diffstat (limited to 'stlport/stl/_cmath.h')
-rw-r--r-- | stlport/stl/_cmath.h | 605 |
1 files changed, 0 insertions, 605 deletions
diff --git a/stlport/stl/_cmath.h b/stlport/stl/_cmath.h deleted file mode 100644 index 771c27d..0000000 --- a/stlport/stl/_cmath.h +++ /dev/null @@ -1,605 +0,0 @@ -/* - * Copyright (c) 1999 - * Boris Fomitchev - * - * This material is provided "as is", with absolutely no warranty expressed - * or implied. Any use is at your own risk. - * - * Permission to use or copy this software for any purpose is hereby granted - * without fee, provided the above notices are retained on all copies. - * Permission to modify the code and to distribute modified code is granted, - * provided the above notices are retained, and a notice that the code was - * modified is included with the above copyright notice. - * - */ - -#ifndef _STLP_INTERNAL_CMATH -#define _STLP_INTERNAL_CMATH - -/* gcc do not like when a using directive appear after a function - * declaration. cmath have abs overloads and cstdlib a using directive - * so cstdlib has to be included first. - */ -#if defined (__GNUC__) && defined (_STLP_USE_NEW_C_HEADERS) -# if defined (_STLP_HAS_INCLUDE_NEXT) -# include_next <cstdlib> -# else -# include _STLP_NATIVE_CPP_C_HEADER(cstdlib) -# endif -#endif - -#if defined (_STLP_USE_NEW_C_HEADERS) -# if defined (_STLP_HAS_NO_NAMESPACES) && !defined (exception) -# define exception __math_exception -# endif -# if defined (_STLP_HAS_INCLUDE_NEXT) -# include_next <cmath> -# else -# include _STLP_NATIVE_CPP_C_HEADER(cmath) -# endif -# if defined (_STLP_HAS_NO_NAMESPACES) -# undef exception -# endif -#else -# include <math.h> -#endif - -#if (defined (__SUNPRO_CC) && (__SUNPRO_CC > 0x500)) || \ - !(defined (__IBMCPP__) && (__IBMCPP__ >= 500) || !(defined(__HP_aCC) && (__HP_aCC >= 30000) )) -# if !defined(_STLP_HAS_NO_NAMESPACES) && !defined(__SUNPRO_CC) -// All the other hypot stuff is going to be at file scope, so follow along here. -namespace std { -# endif -extern "C" double hypot(double x, double y); -# if !defined(_STLP_HAS_NO_NAMESPACES) && !defined(__SUNPRO_CC) -} -# endif - -#endif - -#if defined (__sun) && defined (__GNUC__) -extern "C" { - float __cosf(float v); - float __sinf(float v); - float __atan2f(float, float); - float __coshf(float v); - float __sinhf(float v); - float __sqrtf(float v); - float __expf(float v); - float __logf(float v); - float __log10f(float v); - - long double __cosl(long double v); - long double __sinl(long double v); - long double __atan2l(long double, long double); - long double __coshl(long double v); - long double __sinhl(long double v); - long double __sqrtl(long double v); - long double __expl(long double v); - long double __logl(long double v); - long double __log10l(long double v); -} - -extern "C" { - inline float cosf(float v) { return __cosf(v); } - inline float sinf(float v) { return __sinf(v); } - inline float atan2f(float v1, float v2) { return __atan2f(v1,v2); } - inline float coshf(float v) { return __coshf(v); } - inline float sinhf(float v) { return __sinhf(v); } - inline float sqrtf(float v) { return __sqrtf(v); } - inline float expf(float v) { return __expf(v); } - inline float logf(float v) { return __logf(v); } - inline float log10f(float v) { return __log10f(v); } - - inline long double cosl(long double v) { return __cosl(v); } - inline long double sinl(long double v) { return __sinl(v); } - inline long double atan2l(long double v1, long double v2) { return __atan2l(v1,v2); } - inline long double coshl(long double v) { return __coshl(v); } - inline long double sinhl(long double v) { return __sinhl(v); } - inline long double sqrtl(long double v) { return __sqrtl(v); } - inline long double expl(long double v) { return __expl(v); } - inline long double logl(long double v) { return __logl(v); } - inline long double log10l(long double v) { return __log10l(v); } -} -#endif // __sun && __GNUC__ - -#if defined (__sun) -extern "C" { -extern float __acosf(float); -extern float __asinf(float); -extern float __atanf(float); -extern float __atan2f(float, float); -extern float __ceilf(float); -extern float __cosf(float); -extern float __coshf(float); -extern float __expf(float); -extern float __fabsf(float); -extern float __floorf(float); -extern float __fmodf(float, float); -extern float __frexpf(float, int *); -extern float __ldexpf(float, int); -extern float __logf(float); -extern float __log10f(float); -extern float __modff(float, float *); -extern float __powf(float, float); -extern float __sinf(float); -extern float __sinhf(float); -extern float __sqrtf(float); -extern float __tanf(float); -extern float __tanhf(float); - -extern long double __acosl(long double); -extern long double __asinl(long double); -extern long double __atanl(long double); -extern long double __atan2l(long double, long double); -extern long double __ceill(long double); -extern long double __cosl(long double); -extern long double __coshl(long double); -extern long double __expl(long double); -extern long double __fabsl(long double); -extern long double __floorl(long double); -extern long double __fmodl(long double, long double); -extern long double __frexpl(long double, int *); -extern long double __ldexpl(long double, int); -extern long double __logl(long double); -extern long double __log10l(long double); -extern long double __modfl(long double, long double *); -extern long double __powl(long double, long double); -extern long double __sinl(long double); -extern long double __sinhl(long double); -extern long double __sqrtl(long double); -extern long double __tanl(long double); -extern long double __tanhl(long double); -} -#endif - -#if defined (__BORLANDC__) -# define _STLP_CMATH_FUNC_NAMESPACE _STLP_VENDOR_CSTD -#else -# define _STLP_CMATH_FUNC_NAMESPACE -#endif - -#if !defined (__sun) || defined (__GNUC__) -# define _STLP_MATH_INLINE(float_type, func, cfunc) \ - inline float_type func (float_type x) { return _STLP_CMATH_FUNC_NAMESPACE::cfunc(x); } -# define _STLP_MATH_INLINE2(float_type, type, func, cfunc) \ - inline float_type func (float_type x, type y) { return _STLP_CMATH_FUNC_NAMESPACE::cfunc(x, y); } -# define _STLP_MATH_INLINE_D(float_type, func, cfunc) -# define _STLP_MATH_INLINE2_D(float_type, type, func, cfunc) -#else -# ifdef __SUNPRO_CC -# define _STLP_MATH_INLINE(float_type, func, cfunc) \ - inline float_type func (float_type x) { return _STLP_VENDOR_CSTD::__##cfunc(x); } -# define _STLP_MATH_INLINE_D(float_type, func, cfunc) \ - inline float_type func (float_type x) { return _STLP_VENDOR_CSTD::cfunc(x); } -# define _STLP_MATH_INLINE2(float_type, type, func, cfunc) \ - inline float_type func (float_type x, type y) { return _STLP_VENDOR_CSTD::__##cfunc(x,y); } -# define _STLP_MATH_INLINE2_D(float_type, type, func, cfunc) \ - inline float_type func (float_type x, type y) { return _STLP_VENDOR_CSTD::cfunc(x,y); } -# else -# error Unknown compiler for the Sun platform -# endif -#endif - -/** macros to define math functions -These macros (having an X somewhere in the name) forward to the C library's -double functions but cast the arguments and return values to the given type. */ - -#define _STLP_MATH_INLINEX(__type,func,cfunc) \ - inline __type func (__type x) \ - { return __STATIC_CAST(__type, _STLP_CMATH_FUNC_NAMESPACE::cfunc((double)x)); } -#define _STLP_MATH_INLINE2X(__type1,__type2,func,cfunc) \ - inline __type1 func (__type1 x, __type2 y) \ - { return __STATIC_CAST(__type1, _STLP_CMATH_FUNC_NAMESPACE::cfunc((double)x, y)); } -#define _STLP_MATH_INLINE2PX(__type,func,cfunc) \ - inline __type func (__type x, __type *y) { \ - double tmp1, tmp2; \ - tmp1 = _STLP_CMATH_FUNC_NAMESPACE::cfunc(__STATIC_CAST(double, x), &tmp2); \ - *y = __STATIC_CAST(__type, tmp2); \ - return __STATIC_CAST(__type, tmp1); \ - } -#define _STLP_MATH_INLINE2XX(__type,func,cfunc) \ - inline __type func (__type x, __type y) \ - { return __STATIC_CAST(__type, _STLP_CMATH_FUNC_NAMESPACE::cfunc((double)x, (double)y)); } - - -/** rough characterization of compiler and native C library -For the compiler, it can either support long double or not. If it doesn't, the -macro _STLP_NO_LONG_DOUBLE is defined and we don't define any long double -overloads. -For the native C library the question is whether it has variants with an 'f' -suffix (for float as opposed to double) or an 'l' suffix (for long double). If -the float variants are missing, _STLP_NO_VENDOR_MATH_F is defined, when the -long double variants are missing, _STLP_NO_VENDOR_MATH_L is defined. Of course -the latter doesn't make sense anyway when the compiler already has no long -double support. - -Those two traits determine a) which overloads get defined and b) how they are -defined. - -Meaning of suffixes: -"" : function returning and taking a float_type -"2" : function returning a float_type and taking to float_types -"2P" : function returning a float_type and taking a float_type and a float_type* -"2PI": function returning a float_type and taking a float_type and an int* -"2I" : function returning a float_type and taking a float_Type and an int -*/ - -#if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_NO_VENDOR_MATH_L) && !defined (_STLP_NO_VENDOR_MATH_F) - // long double support and both e.g. sinl(long double) and sinf(float) - // This is the default for a correct and complete native library. -# define _STLP_DEF_MATH_INLINE(func,cf) \ - _STLP_MATH_INLINE(float,func,cf##f) \ - _STLP_MATH_INLINE_D(double,func,cf) \ - _STLP_MATH_INLINE(long double,func,cf##l) -# define _STLP_DEF_MATH_INLINE2(func,cf) \ - _STLP_MATH_INLINE2(float,float,func,cf##f) \ - _STLP_MATH_INLINE2_D(double,double,func,cf) \ - _STLP_MATH_INLINE2(long double,long double,func,cf##l) -# define _STLP_DEF_MATH_INLINE2P(func,cf) \ - _STLP_MATH_INLINE2(float,float *,func,cf##f) \ - _STLP_MATH_INLINE2_D(double,double *,func,cf) \ - _STLP_MATH_INLINE2(long double,long double *,func,cf##l) -# define _STLP_DEF_MATH_INLINE2PI(func,cf) \ - _STLP_MATH_INLINE2(float,int *,func,cf##f) \ - _STLP_MATH_INLINE2_D(double,int *,func,cf) \ - _STLP_MATH_INLINE2(long double,int *,func,cf##l) -# define _STLP_DEF_MATH_INLINE2I(func,cf) \ - _STLP_MATH_INLINE2(float,int,func,cf##f) \ - _STLP_MATH_INLINE2_D(double,int,func,cf) \ - _STLP_MATH_INLINE2(long double,int,func,cf##l) -#else -# if !defined (_STLP_NO_LONG_DOUBLE) -# if !defined (_STLP_NO_VENDOR_MATH_F) - // long double support and e.g. sinf(float) but not e.g. sinl(long double) -# define _STLP_DEF_MATH_INLINE(func,cf) \ - _STLP_MATH_INLINE(float,func,cf##f) \ - _STLP_MATH_INLINEX(long double,func,cf) -# define _STLP_DEF_MATH_INLINE2(func,cf) \ - _STLP_MATH_INLINE2(float,float,func,cf##f) \ - _STLP_MATH_INLINE2XX(long double,func,cf) -# define _STLP_DEF_MATH_INLINE2P(func,cf) \ - _STLP_MATH_INLINE2(float,float *,func,cf##f) \ - _STLP_MATH_INLINE2PX(long double,func,cf) -# define _STLP_DEF_MATH_INLINE2PI(func,cf) \ - _STLP_MATH_INLINE2(float,int *,func,cf##f) \ - _STLP_MATH_INLINE2X(long double,int *,func,cf) -# define _STLP_DEF_MATH_INLINE2I(func,cf) \ - _STLP_MATH_INLINE2(float,int,func,cf##f) \ - _STLP_MATH_INLINE2X(long double,int,func,cf) -# elif !defined (_STLP_NO_VENDOR_MATH_L) - // long double support and e.g. sinl(long double) but not e.g. sinf(float) -# define _STLP_DEF_MATH_INLINE(func,cf) \ - _STLP_MATH_INLINEX(float,func,cf) \ - _STLP_MATH_INLINE(long double,func,cf##l) -# define _STLP_DEF_MATH_INLINE2(func,cf) \ - _STLP_MATH_INLINE2XX(float,func,cf) \ - _STLP_MATH_INLINE2(long double,long double,func,cf##l) -# define _STLP_DEF_MATH_INLINE2P(func,cf) \ - _STLP_MATH_INLINE2PX(float,func,cf) \ - _STLP_MATH_INLINE2(long double,long double *,func,cf##l) -# define _STLP_DEF_MATH_INLINE2PI(func,cf) \ - _STLP_MATH_INLINE2X(float,int *,func,cf) \ - _STLP_MATH_INLINE2(long double,int *,func,cf##l) -# define _STLP_DEF_MATH_INLINE2I(func,cf) \ - _STLP_MATH_INLINE2X(float,int,func,cf) \ - _STLP_MATH_INLINE2(long double,int,func,cf##l) -# else -# define _STLP_DEF_MATH_INLINE(func,cf) \ - _STLP_MATH_INLINEX(float,func,cf) \ - _STLP_MATH_INLINEX(long double,func,cf) -# define _STLP_DEF_MATH_INLINE2(func,cf) \ - _STLP_MATH_INLINE2XX(float,func,cf) \ - _STLP_MATH_INLINE2XX(long double,func,cf) -# define _STLP_DEF_MATH_INLINE2P(func,cf) \ - _STLP_MATH_INLINE2PX(float,func,cf) \ - _STLP_MATH_INLINE2PX(long double,func,cf) -# define _STLP_DEF_MATH_INLINE2PI(func,cf) \ - _STLP_MATH_INLINE2X(float,int *,func,cf) \ - _STLP_MATH_INLINE2X(long double,int *,func,cf) -# define _STLP_DEF_MATH_INLINE2I(func,cf) \ - _STLP_MATH_INLINE2X(float,int,func,cf) \ - _STLP_MATH_INLINE2X(long double,int,func,cf) -# endif -# else -# if !defined (_STLP_NO_VENDOR_MATH_F) -# define _STLP_DEF_MATH_INLINE(func,cf) \ - _STLP_MATH_INLINE(float,func,cf##f) -# define _STLP_DEF_MATH_INLINE2(func,cf) \ - _STLP_MATH_INLINE2(float,float,func,cf##f) -# define _STLP_DEF_MATH_INLINE2P(func,cf) \ - _STLP_MATH_INLINE2(float,float *,func,cf##f) -# define _STLP_DEF_MATH_INLINE2PI(func,cf) \ - _STLP_MATH_INLINE2(float,int *,func,cf##f) -# define _STLP_DEF_MATH_INLINE2I(func,cf) \ - _STLP_MATH_INLINE2(float,int,func,cf##f) -# else // _STLP_NO_VENDOR_MATH_F - // neither long double support nor e.g. sinf(float) functions -# define _STLP_DEF_MATH_INLINE(func,cf) \ - _STLP_MATH_INLINEX(float,func,cf) -# define _STLP_DEF_MATH_INLINE2(func,cf) \ - _STLP_MATH_INLINE2XX(float,func,cf) -# define _STLP_DEF_MATH_INLINE2P(func,cf) \ - _STLP_MATH_INLINE2PX(float,func,cf) -# define _STLP_DEF_MATH_INLINE2PI(func,cf) \ - _STLP_MATH_INLINE2X(float,int *,func,cf) -# define _STLP_DEF_MATH_INLINE2I(func,cf) \ - _STLP_MATH_INLINE2X(float,int,func,cf) -# endif // _STLP_NO_VENDOR_MATH_F -# endif -#endif - -#if defined (_STLP_WCE) || \ - (defined(_STLP_MSVC) && (_STLP_MSVC <= 1300) && defined (_MSC_EXTENSIONS) /* && !defined(_STLP_WCE_NET) */) -/* - * dums: VC6 has all the required C++ functions but only define them if - * _MSC_EXTENSIONS is not defined (a bug?). STLport just do the same - * thing also when _MSC_EXTENSIONS is defined. - * TODO: above check (_STLP_MSVC <= 1300) also catches VC7.0, is that intended? - */ -//We have to tell the compilers that abs, acos ... math functions are not intrinsic -//otherwise we have Internal Compiler Error in release mode... -# pragma warning(push) -# pragma warning(disable: 4162) // no function with C linkage found -# pragma warning(disable: 4163) // not available as an intrinsic function -# pragma function (abs, acos, asin, atan, atan2, cos, cosh, exp, fabs, fmod, log, log10, sin, sinh, sqrt, tan, tanh) -# if defined (_STLP_WCE) -# pragma function (ceil, floor) -# endif -# define _STLP_RESTORE_FUNCTION_INTRINSIC -#endif // _STLP_MSVC && _STLP_MSVC <= 1300 && !_STLP_WCE && _MSC_EXTENSIONS - -#if (defined (__BORLANDC__) || defined (__WATCOMC__)) && defined (_STLP_USE_NEW_C_HEADERS) -/* In this config Borland native lib only define functions in std namespace. - * In order to have all overloads in STLport namespace we need to add the - * double overload in global namespace. We do not use a using statement to avoid - * import of invalid overload. - */ -# define _STLP_DMATH_INLINE(func) _STLP_MATH_INLINE(double, func, func) -# define _STLP_DMATH_INLINE2(func) _STLP_MATH_INLINE2(double, double, func, func) - -_STLP_DMATH_INLINE(acos) -_STLP_DMATH_INLINE(asin) -_STLP_DMATH_INLINE(atan) -_STLP_DMATH_INLINE2(atan2) -_STLP_DMATH_INLINE(ceil) -_STLP_DMATH_INLINE(cos) -_STLP_DMATH_INLINE(cosh) -_STLP_DMATH_INLINE(exp) -_STLP_DMATH_INLINE(fabs) -_STLP_DMATH_INLINE(floor) -_STLP_DMATH_INLINE2(fmod) -_STLP_MATH_INLINE2X(double, int*, frexp, frexp) -_STLP_MATH_INLINE2X(double, int, ldexp, ldexp) -_STLP_DMATH_INLINE(log) -_STLP_DMATH_INLINE(log10) -_STLP_MATH_INLINE2PX(double, modf, modf) -_STLP_DMATH_INLINE(sin) -_STLP_DMATH_INLINE(sinh) -_STLP_DMATH_INLINE(sqrt) -_STLP_DMATH_INLINE(tan) -_STLP_DMATH_INLINE(tanh) -_STLP_DMATH_INLINE2(pow) -_STLP_DMATH_INLINE2(hypot) - -# undef _STLP_DMATH_INLINE -# undef _STLP_DMATH_INLINE2 -#endif - -#if defined (__DMC__) -# if defined (fabs) -inline double __stlp_fabs(double __x) { return fabs(__x); } -# undef fabs -inline double fabs(double __x) { return __stlp_fabs(__x); } -# endif -# if defined (cos) -inline double __stlp_cos(double __x) { return cos(__x); } -# undef cos -inline double cos(double __x) { return __stlp_cos(__x); } -# endif -# if defined (sin) -inline double __stlp_sin(double __x) { return sin(__x); } -# undef sin -inline double sin(double __x) { return __stlp_sin(__x); } -# endif -# if defined (sqrt) -inline double __stlp_sqrt(double __x) { return sqrt(__x); } -# undef sqrt -inline double sqrt(double __x) { return __stlp_sqrt(__x); } -# endif -# if defined (ldexp) -inline double __stlp_ldexp(double __x, int __y) { return ldexp(__x, __y); } -# undef ldexp -inline double ldexp(double __x, int __y) { return __stlp_ldexp(__x, __y); } -# endif -#endif - -/* MSVC native lib starting with .Net 2003 has already all math functions - * in global namespace. - * HP-UX native lib has math functions in the global namespace. - */ -#if (!defined (_STLP_MSVC_LIB) || (_STLP_MSVC_LIB < 1310) || defined(UNDER_CE)) && \ - (!defined (__HP_aCC) || (__HP_aCC < 30000)) && \ - !defined (__WATCOMC__) -inline double abs(double __x) -{ return ::fabs(__x); } -# if !defined (__MVS__) -_STLP_DEF_MATH_INLINE(abs, fabs) -# else // __MVS__ has native long double abs? -inline float abs(float __x) { return ::fabsf(__x); } -# endif - -_STLP_DEF_MATH_INLINE(acos, acos) -_STLP_DEF_MATH_INLINE(asin, asin) -_STLP_DEF_MATH_INLINE(atan, atan) -_STLP_DEF_MATH_INLINE2(atan2, atan2) -_STLP_DEF_MATH_INLINE(ceil, ceil) -_STLP_DEF_MATH_INLINE(cos, cos) -_STLP_DEF_MATH_INLINE(cosh, cosh) -_STLP_DEF_MATH_INLINE(exp, exp) -_STLP_DEF_MATH_INLINE(fabs, fabs) -_STLP_DEF_MATH_INLINE(floor, floor) -_STLP_DEF_MATH_INLINE2(fmod, fmod) -_STLP_DEF_MATH_INLINE2PI(frexp, frexp) -_STLP_DEF_MATH_INLINE2I(ldexp, ldexp) -_STLP_DEF_MATH_INLINE(log, log) -_STLP_DEF_MATH_INLINE(log10, log10) -_STLP_DEF_MATH_INLINE2P(modf, modf) -_STLP_DEF_MATH_INLINE(sin, sin) -_STLP_DEF_MATH_INLINE(sinh, sinh) -_STLP_DEF_MATH_INLINE(sqrt, sqrt) -_STLP_DEF_MATH_INLINE(tan, tan) -_STLP_DEF_MATH_INLINE(tanh, tanh) -_STLP_DEF_MATH_INLINE2(pow, pow) - -# if !defined(_STLP_MSVC) /* || (_STLP_MSVC > 1300) */ || defined(_STLP_WCE) || !defined (_MSC_EXTENSIONS) /* && !defined(_STLP_WCE_NET) */ -# ifndef _STLP_NO_VENDOR_MATH_F -# ifndef __sun -inline float pow(float __x, int __y) { return _STLP_CMATH_FUNC_NAMESPACE::powf(__x, __STATIC_CAST(float,__y)); } -# else -inline float pow(float __x, int __y) { return ::__powf(__x, __STATIC_CAST(float,__y)); } -# endif -# else -inline float pow(float __x, int __y) { return __STATIC_CAST(float, _STLP_CMATH_FUNC_NAMESPACE::pow(__x, __STATIC_CAST(float,__y))); } -# endif -inline double pow(double __x, int __y) { return _STLP_CMATH_FUNC_NAMESPACE::pow(__x, __STATIC_CAST(double,__y)); } -# if !defined (_STLP_NO_LONG_DOUBLE) -# if !defined(_STLP_NO_VENDOR_MATH_L) -# ifndef __sun -inline long double pow(long double __x, int __y) { return _STLP_CMATH_FUNC_NAMESPACE::powl(__x, __STATIC_CAST(long double,__y)); } -# else -# ifndef __SUNPRO_CC -inline long double pow(long double __x, int __y) { return ::__powl(__x, __STATIC_CAST(long double,__y)); } -# else -inline long double pow(long double __x, int __y) { return _STLP_VENDOR_CSTD::__powl(__x, __STATIC_CAST(long double,__y)); } -# endif -# endif -# else -inline long double pow(long double __x, int __y) { return __STATIC_CAST(long double, _STLP_CMATH_FUNC_NAMESPACE::pow(__x, __STATIC_CAST(long double,__y))); } -# endif -# endif -# else -//The MS native pow version has a bugged overload so it is not imported -//in the STLport namespace. -//Here is the bugged version: -//inline double pow(int __x, int __y) { return (_Pow_int(__x, __y)); } -inline double pow(double __x, int __y) { return (_Pow_int(__x, __y)); } -inline float pow(float __x, int __y) { return (_Pow_int(__x, __y)); } -inline long double pow(long double __x, int __y) { return (_Pow_int(__x, __y)); } -# endif -#endif - -#if (defined (_STLP_MSVC) && !defined (_STLP_WCE)) || defined (__ICL) || defined (__sun) -# if defined (_STLP_MSVC) && (_STLP_MSVC >= 1400) -# pragma warning (push) -# pragma warning (disable : 4996) // hypot is deprecated. -# endif -_STLP_MATH_INLINE2XX(float, hypot, hypot) -inline long double hypot(long double x, long double y) { return sqrt(x * x + y * y); } -# if defined (_STLP_MSVC) && (_STLP_MSVC >= 1400) -# pragma warning (pop) -# endif -#else -# if defined (_STLP_USE_UCLIBC) -inline double hypot(double x, double y) { return sqrt(x * x + y * y); } -_STLP_DEF_MATH_INLINE2(hypot, hypot) -# elif defined (_STLP_WCE) - /* CE has a double _hypot(double,double) which we use */ -inline double hypot(double __x, double __y) { return _hypot(__x,__y); } -_STLP_DEF_MATH_INLINE2(hypot, _hypot) -# endif -#endif - -#if defined (_STLP_RESTORE_FUNCTION_INTRINSIC) -//restoration of the default intrinsic status of those functions: -# pragma intrinsic (abs, acos, asin, atan, atan2, cos, cosh, exp, fabs, fmod, log, log10, sin, sinh, sqrt, tan, tanh) -# if defined (_STLP_WCE) -# pragma intrinsic (ceil, floor) -# endif -# pragma warning(pop) -# undef _STLP_RESTORE_FUNCTION_INTRINSIC -#endif // _STLP_MSVC && _STLP_MSVC <= 1300 && !_STLP_WCE && _MSC_EXTENSIONS - -/* C++ Standard is unclear about several call to 'using ::func' if new overloads - * of ::func appears between 2 successive 'using' calls. To avoid this potential - * problem we provide all abs overload before the 'using' call. - * Beware: This header inclusion has to be after all abs overload of this file. - * The first 'using ::abs' call is going to be in the other header. - */ -#ifndef _STLP_INTERNAL_CSTDLIB -# include <stl/_cstdlib.h> -#endif - -#if defined (_STLP_IMPORT_VENDOR_CSTD) && !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS) -#if defined (__ANDROID__) -namespace __captured { -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_signbit(_Tp __f) { return signbit(__f); } -} -#undef isfinite -#undef isinf -#undef isnan -#undef signbit -namespace __captured { -template<typename _Tp> inline int isfinite(_Tp __f) { return __capture_isfinite(__f); } -template<typename _Tp> inline int isinf(_Tp __f) { return __capture_isinf(__f); } -template<typename _Tp> inline int isnan(_Tp __f) { return __capture_isnan(__f); } -template<typename _Tp> inline int signbit(_Tp __f) { return __capture_signbit(__f); } -} -#endif -_STLP_BEGIN_NAMESPACE -using ::abs; -using ::acos; -using ::asin; -using ::atan; -using ::atan2; -using ::ceil; -using ::cos; -using ::cosh; -using ::exp; -using ::fabs; -using ::floor; -using ::fmod; -using ::frexp; -/* - Because of some weird interaction between STLport headers - and native HP-UX headers, when compiled with _STLP_DEBUG - macro defined with aC++, hypot() is not declared. - At some point we'll need to get to the bottom line of - this problem. -*/ -#if !(defined(__HP_aCC) && defined(_STLP_DEBUG)) -using ::hypot; -#endif -#if defined (__ANDROID__) -using __captured::isfinite; -using __captured::isinf; -using __captured::isnan; -#endif -using ::ldexp; -using ::log; -using ::log10; -using ::modf; -using ::pow; -#if defined (__ANDROID__) -using __captured::signbit; -#endif -using ::sin; -using ::sinh; -using ::sqrt; -using ::tan; -using ::tanh; -_STLP_END_NAMESPACE -# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x560) && !defined (__linux__) -using _STLP_VENDOR_CSTD::_ecvt; -using _STLP_VENDOR_CSTD::_fcvt; -# endif -#endif - -#endif /* _STLP_INTERNAL_CMATH */ - -// Local Variables: -// mode:C++ -// End: |