special_function_util.h

Go to the documentation of this file.
00001 // Special functions -*- C++ -*-
00002 
00003 // Copyright (C) 2006, 2009
00004 // Free Software Foundation, Inc.
00005 //
00006 // This file is part of the GNU ISO C++ Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the GNU General Public License as published by the
00009 // Free Software Foundation; either version 3, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 
00017 // Under Section 7 of GPL version 3, you are granted additional
00018 // permissions described in the GCC Runtime Library Exception, version
00019 // 3.1, as published by the Free Software Foundation.
00020 
00021 // You should have received a copy of the GNU General Public License and
00022 // a copy of the GCC Runtime Library Exception along with this program;
00023 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00024 // <http://www.gnu.org/licenses/>.
00025 
00026 /** @file tr1/special_function_util.h
00027  *  This is an internal header file, included by other library headers.
00028  *  You should not attempt to use it directly.
00029  */
00030 
00031 //
00032 // ISO C++ 14882 TR1: 5.2  Special functions
00033 //
00034 
00035 // Written by Edward Smith-Rowland based on numerous mathematics books.
00036 
00037 #ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
00038 #define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
00039 
00040 namespace std
00041 {
00042 namespace tr1
00043 {
00044 
00045   namespace __detail
00046   {
00047 
00048     /// A class to encapsulate type dependent floating point
00049     /// constants.  Not everything will be able to be expressed as
00050     /// type logic.
00051     template<typename _Tp>
00052     struct __floating_point_constant
00053     {
00054       static const _Tp __value;
00055     };
00056 
00057 
00058     /// A structure for numeric constants.
00059     template<typename _Tp>
00060       struct __numeric_constants
00061       {
00062         ///  Constant @f$ \pi @f$.
00063         static _Tp __pi() throw()
00064         { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
00065         ///  Constant @f$ \pi / 2 @f$.
00066         static _Tp __pi_2() throw()
00067         { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
00068         ///  Constant @f$ \pi / 3 @f$.
00069         static _Tp __pi_3() throw()
00070         { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
00071         ///  Constant @f$ \pi / 4 @f$.
00072         static _Tp __pi_4() throw()
00073         { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
00074         ///  Constant @f$ 1 / \pi @f$.
00075         static _Tp __1_pi() throw()
00076         { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
00077         ///  Constant @f$ 2 / \sqrt(\pi) @f$.
00078         static _Tp __2_sqrtpi() throw()
00079         { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
00080         ///  Constant @f$ \sqrt(2) @f$.
00081         static _Tp __sqrt2() throw()
00082         { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
00083         ///  Constant @f$ \sqrt(3) @f$.
00084         static _Tp __sqrt3() throw()
00085         { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
00086         ///  Constant @f$ \sqrt(\pi/2) @f$.
00087         static _Tp __sqrtpio2() throw()
00088         { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
00089         ///  Constant @f$ 1 / sqrt(2) @f$.
00090         static _Tp __sqrt1_2() throw()
00091         { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
00092         ///  Constant @f$ \log(\pi) @f$.
00093         static _Tp __lnpi() throw()
00094         { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
00095         ///  Constant Euler's constant @f$ \gamma_E @f$.
00096         static _Tp __gamma_e() throw()
00097         { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
00098         ///  Constant Euler-Mascheroni @f$ e @f$
00099         static _Tp __euler() throw()
00100         { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
00101       };
00102 
00103 
00104 #if _GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
00105 
00106     /// This is a wrapper for the isnan function. Otherwise, for NaN,
00107     /// all comparisons result in false. If/when we build a std::isnan
00108     /// out of intrinsics, this will disappear completely in favor of
00109     /// std::isnan.
00110     template<typename _Tp>
00111     inline bool __isnan(const _Tp __x)
00112     {
00113       return std::isnan(__x);
00114     }
00115 
00116 #else
00117 
00118     template<typename _Tp>
00119     inline bool __isnan(const _Tp __x)
00120     {
00121       return __builtin_isnan(__x);
00122     }
00123 
00124     template<>
00125     inline bool __isnan<float>(const float __x)
00126     {
00127       return __builtin_isnanf(__x);
00128     }
00129 
00130     template<>
00131     inline bool __isnan<long double>(const long double __x)
00132     {
00133       return __builtin_isnanl(__x);
00134     }
00135 
00136 #endif
00137 
00138   } // namespace __detail
00139 
00140 }
00141 }
00142 
00143 #endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
00144 

Generated on Thu Jul 23 21:16:17 2009 for libstdc++ by  doxygen 1.5.8