libstdc++: cmath Source File

00001 // TR1 cmath -*- C++ -*-
00002 
00003 // Copyright (C) 2006 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 2, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // You should have received a copy of the GNU General Public License along
00017 // with this library; see the file COPYING.  If not, write to the Free
00018 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00019 // USA.
00020 
00021 // As a special exception, you may use this file as part of a free software
00022 // library without restriction.  Specifically, if other files instantiate
00023 // templates or use macros or inline functions from this file, or you compile
00024 // this file and link it with other files to produce an executable, this
00025 // file does not by itself cause the resulting executable to be covered by
00026 // the GNU General Public License.  This exception does not however
00027 // invalidate any other reasons why the executable file might be covered by
00028 // the GNU General Public License.
00029 
00030 /** @file tr1/cmath
00031  *  This is a TR1 C++ Library header. 
00032  */
00033 
00034 #ifndef _TR1_CMATH
00035 #define _TR1_CMATH 1
00036 
00037 #include <bits/c++config.h>
00038 #include <cmath>
00039 #include <tr1/common.h>
00040 
00041 #if _GLIBCXX_USE_C99_MATH_TR1
00042 
00043 #undef acosh
00044 #undef acoshf
00045 #undef acoshl
00046 #undef asinh
00047 #undef asinhf
00048 #undef asinhl
00049 #undef atanh
00050 #undef atanhf
00051 #undef atanhl
00052 #undef cbrt
00053 #undef cbrtf
00054 #undef cbrtl
00055 #undef copysign
00056 #undef copysignf
00057 #undef copysignl
00058 #undef erf
00059 #undef erff
00060 #undef erfl
00061 #undef erfc
00062 #undef erfcf
00063 #undef erfcl
00064 #undef exp2
00065 #undef exp2f
00066 #undef exp2l
00067 #undef expm1
00068 #undef expm1f
00069 #undef expm1l
00070 #undef fdim
00071 #undef fdimf
00072 #undef fdiml
00073 #undef fma
00074 #undef fmaf
00075 #undef fmal
00076 #undef fmax
00077 #undef fmaxf
00078 #undef fmaxl
00079 #undef fmin
00080 #undef fminf
00081 #undef fminl
00082 #undef hypot
00083 #undef hypotf
00084 #undef hypotl
00085 #undef ilogb
00086 #undef ilogbf
00087 #undef ilogbl
00088 #undef lgamma
00089 #undef lgammaf
00090 #undef lgammal
00091 #undef llrint
00092 #undef llrintf
00093 #undef llrintl
00094 #undef llround
00095 #undef llroundf
00096 #undef llroundl
00097 #undef log1p
00098 #undef log1pf
00099 #undef log1pl
00100 #undef log2
00101 #undef log2f
00102 #undef log2l
00103 #undef logb
00104 #undef logbf
00105 #undef logbl
00106 #undef lrint
00107 #undef lrintf
00108 #undef lrintl
00109 #undef lround
00110 #undef lroundf
00111 #undef lroundl
00112 #undef nan
00113 #undef nanf
00114 #undef nanl
00115 #undef nearbyint
00116 #undef nearbyintf
00117 #undef nearbyintl
00118 #undef nextafter
00119 #undef nextafterf
00120 #undef nextafterl
00121 #undef nexttoward
00122 #undef nexttowardf
00123 #undef nexttowardl
00124 #undef remainder
00125 #undef remainderf
00126 #undef remainderl
00127 #undef remquo
00128 #undef remquo
00129 #undef remquo
00130 #undef rint
00131 #undef rintf
00132 #undef rintl
00133 #undef round
00134 #undef roundf
00135 #undef roundl
00136 #undef scalbln
00137 #undef scalblnf
00138 #undef scalblnl
00139 #undef scalbn
00140 #undef scalbnf
00141 #undef scalbnl
00142 #undef tgamma
00143 #undef tgammaf
00144 #undef tgammal
00145 #undef trunc
00146 #undef truncf
00147 #undef truncl
00148 
00149 #endif
00150 
00151 // namespace std::tr1
00152 namespace std
00153 {
00154 _GLIBCXX_BEGIN_NAMESPACE(tr1)
00155 
00156 #if _GLIBCXX_USE_C99_MATH_TR1
00157 
00158   // types
00159   using ::double_t;
00160   using ::float_t;
00161 
00162   // functions
00163   using ::acosh;
00164   using ::acoshf;
00165   using ::acoshl;
00166 
00167   using ::asinh;
00168   using ::asinhf;
00169   using ::asinhl;
00170 
00171   using ::atanh;
00172   using ::atanhf;
00173   using ::atanhl;
00174 
00175   using ::cbrt;
00176   using ::cbrtf;
00177   using ::cbrtl;
00178 
00179   using ::copysign;
00180   using ::copysignf;
00181   using ::copysignl;
00182 
00183   using ::erf;
00184   using ::erff;
00185   using ::erfl;
00186 
00187   using ::erfc;
00188   using ::erfcf;
00189   using ::erfcl;
00190 
00191   using ::exp2;
00192   using ::exp2f;
00193   using ::exp2l;
00194 
00195   using ::expm1;
00196   using ::expm1f;
00197   using ::expm1l;
00198 
00199   using ::fdim;
00200   using ::fdimf;
00201   using ::fdiml;
00202 
00203   using ::fma;
00204   using ::fmaf;
00205   using ::fmal;
00206 
00207   using ::fmax;
00208   using ::fmaxf;
00209   using ::fmaxl;
00210 
00211   using ::fmin;
00212   using ::fminf;
00213   using ::fminl;
00214 
00215   using ::hypot;
00216   using ::hypotf;
00217   using ::hypotl;
00218 
00219   using ::ilogb;
00220   using ::ilogbf;
00221   using ::ilogbl;
00222 
00223   using ::lgamma;
00224   using ::lgammaf;
00225   using ::lgammal;
00226 
00227   using ::llrint;
00228   using ::llrintf;
00229   using ::llrintl;
00230 
00231   using ::llround;
00232   using ::llroundf;
00233   using ::llroundl;
00234 
00235   using ::log1p;
00236   using ::log1pf;
00237   using ::log1pl;
00238 
00239   using ::log2;
00240   using ::log2f;
00241   using ::log2l;
00242 
00243   using ::logb;
00244   using ::logbf;
00245   using ::logbl;
00246 
00247   using ::lrint;
00248   using ::lrintf;
00249   using ::lrintl;
00250 
00251   using ::lround;
00252   using ::lroundf;
00253   using ::lroundl;
00254 
00255   using ::nan;
00256   using ::nanf;
00257   using ::nanl;
00258 
00259   using ::nearbyint;
00260   using ::nearbyintf;
00261   using ::nearbyintl;
00262 
00263   using ::nextafter;
00264   using ::nextafterf;
00265   using ::nextafterl;
00266 
00267   using ::nexttoward;
00268   using ::nexttowardf;
00269   using ::nexttowardl;
00270 
00271   using ::remainder;
00272   using ::remainderf;
00273   using ::remainderl;
00274 
00275   using ::remquo;
00276   using ::remquo;
00277   using ::remquo;
00278 
00279   using ::rint;
00280   using ::rintf;
00281   using ::rintl;
00282 
00283   using ::round;
00284   using ::roundf;
00285   using ::roundl;
00286 
00287   using ::scalbln;
00288   using ::scalblnf;
00289   using ::scalblnl;
00290 
00291   using ::scalbn;
00292   using ::scalbnf;
00293   using ::scalbnl;
00294 
00295   using ::tgamma;
00296   using ::tgammaf;
00297   using ::tgammal;
00298 
00299   using ::trunc;
00300   using ::truncf;
00301   using ::truncl;
00302 
00303 #endif
00304 
00305 #if _GLIBCXX_USE_C99_MATH
00306 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
00307 
00308   /// @brief Function template definitions [8.16.3].
00309   //
00310   using std::signbit;
00311   
00312   using std::fpclassify;
00313 
00314   using std::isfinite;
00315   using std::isinf;
00316   using std::isnan;
00317   using std::isnormal;
00318 
00319   using std::isgreater;
00320   using std::isgreaterequal;
00321   using std::isless;
00322   using std::islessequal;
00323   using std::islessgreater;
00324   using std::isunordered;
00325 #endif
00326 #endif
00327 
00328 #if _GLIBCXX_USE_C99_MATH_TR1
00329 
00330   /// @brief Additional overloads [8.16.4].
00331   //
00332   using std::acos;
00333 
00334   inline float
00335   acosh(float __x)
00336   { return __builtin_acoshf(__x); }
00337 
00338   inline long double
00339   acosh(long double __x)
00340   { return __builtin_acoshl(__x); }
00341 
00342   template<typename _Tp>
00343     inline typename __promote<_Tp>::__type 
00344     acosh(_Tp __x)
00345     {
00346       typedef typename __promote<_Tp>::__type __type;
00347       return acosh(__type(__x));
00348     }
00349 
00350   using std::asin;
00351 
00352   inline float
00353   asinh(float __x)
00354   { return __builtin_asinhf(__x); }
00355 
00356   inline long double
00357   asinh(long double __x)
00358   { return __builtin_asinhl(__x); }
00359 
00360   template<typename _Tp>
00361     inline typename __promote<_Tp>::__type 
00362     asinh(_Tp __x)
00363     {
00364       typedef typename __promote<_Tp>::__type __type;
00365       return asinh(__type(__x));
00366     }
00367 
00368   using std::atan;
00369 
00370   // Workaround for c++/21682.
00371   namespace __detail
00372   {
00373     template<typename _Tp, typename _Up>
00374       inline typename
00375       __gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value
00376                              || std::__is_floating<_Up>::__value,
00377                  typename
00378                  std::tr1::__promote_2<_Tp, _Up>::__type>::__type
00379       atan2(_Tp __y, _Up __x)
00380       {
00381     typedef typename std::tr1::__promote_2<_Tp, _Up>::__type __type;
00382     return std::atan2(__type(__y), __type(__x));
00383       }
00384   } // namespace __detail
00385 
00386   using std::atan2;
00387   using __detail::atan2;
00388  
00389   inline float
00390   atanh(float __x)
00391   { return __builtin_atanhf(__x); }
00392 
00393   inline long double
00394   atanh(long double __x)
00395   { return __builtin_atanhl(__x); }
00396 
00397   template<typename _Tp>
00398     inline typename __promote<_Tp>::__type 
00399     atanh(_Tp __x)
00400     {
00401       typedef typename __promote<_Tp>::__type __type;
00402       return atanh(__type(__x));
00403     }
00404 
00405   inline float
00406   cbrt(float __x)
00407   { return __builtin_cbrtf(__x); }
00408 
00409   inline long double
00410   cbrt(long double __x)
00411   { return __builtin_cbrtl(__x); }
00412 
00413   template<typename _Tp>
00414     inline typename __promote<_Tp>::__type 
00415     cbrt(_Tp __x)
00416     {
00417       typedef typename __promote<_Tp>::__type __type;
00418       return cbrt(__type(__x));
00419     }
00420 
00421   using std::ceil;
00422 
00423   inline float
00424   copysign(float __x, float __y)
00425   { return __builtin_copysignf(__x, __y); }
00426 
00427   inline long double
00428   copysign(long double __x, long double __y)
00429   { return __builtin_copysignl(__x, __y); }
00430 
00431   template<typename _Tp, typename _Up>
00432     inline typename __promote_2<_Tp, _Up>::__type
00433     copysign(_Tp __x, _Up __y)
00434     {
00435       typedef typename __promote_2<_Tp, _Up>::__type __type;
00436       return copysign(__type(__x), __type(__y));
00437     }
00438 
00439   using std::cos;
00440   using std::cosh;  
00441 
00442   inline float
00443   erf(float __x)
00444   { return __builtin_erff(__x); }
00445 
00446   inline long double
00447   erf(long double __x)
00448   { return __builtin_erfl(__x); }
00449 
00450   template<typename _Tp>
00451     inline typename __promote<_Tp>::__type 
00452     erf(_Tp __x)
00453     {
00454       typedef typename __promote<_Tp>::__type __type;
00455       return erf(__type(__x));
00456     }
00457 
00458   inline float
00459   erfc(float __x)
00460   { return __builtin_erfcf(__x); }
00461 
00462   inline long double
00463   erfc(long double __x)
00464   { return __builtin_erfcl(__x); }
00465 
00466   template<typename _Tp>
00467     inline typename __promote<_Tp>::__type 
00468     erfc(_Tp __x)
00469     {
00470       typedef typename __promote<_Tp>::__type __type;
00471       return erfc(__type(__x));
00472     }
00473 
00474   using std::exp;
00475 
00476   inline float
00477   exp2(float __x)
00478   { return __builtin_exp2f(__x); }
00479 
00480   inline long double
00481   exp2(long double __x)
00482   { return __builtin_exp2l(__x); }
00483 
00484   template<typename _Tp>
00485     inline typename __promote<_Tp>::__type 
00486     exp2(_Tp __x)
00487     {
00488       typedef typename __promote<_Tp>::__type __type;
00489       return exp2(__type(__x));
00490     }
00491 
00492   inline float
00493   expm1(float __x)
00494   { return __builtin_expm1f(__x); }
00495 
00496   inline long double
00497   expm1(long double __x)
00498   { return __builtin_expm1l(__x); }
00499 
00500   template<typename _Tp>
00501     inline typename __promote<_Tp>::__type 
00502     expm1(_Tp __x)
00503     {
00504       typedef typename __promote<_Tp>::__type __type;
00505       return expm1(__type(__x));
00506     }
00507 
00508   using std::fabs;
00509 
00510   inline float
00511   fdim(float __x, float __y)
00512   { return __builtin_fdimf(__x, __y); }
00513 
00514   inline long double
00515   fdim(long double __x, long double __y)
00516   { return __builtin_fdiml(__x, __y); }
00517 
00518   template<typename _Tp, typename _Up>
00519     inline typename __promote_2<_Tp, _Up>::__type
00520     fdim(_Tp __x, _Up __y)
00521     {
00522       typedef typename __promote_2<_Tp, _Up>::__type __type;
00523       return fdim(__type(__x), __type(__y));
00524     }
00525 
00526   using std::floor;
00527 
00528   inline float
00529   fma(float __x, float __y, float __z)
00530   { return __builtin_fmaf(__x, __y, __z); }
00531 
00532   inline long double
00533   fma(long double __x, long double __y, long double __z)
00534   { return __builtin_fmal(__x, __y, __z); }
00535 
00536   template<typename _Tp, typename _Up, typename _Vp>
00537     inline typename __promote_3<_Tp, _Up, _Vp>::__type
00538     fma(_Tp __x, _Up __y, _Vp __z)
00539     {
00540       typedef typename __promote_3<_Tp, _Up, _Vp>::__type __type;
00541       return fma(__type(__x), __type(__y), __type(__z));
00542     }
00543 
00544   inline float
00545   fmax(float __x, float __y)
00546   { return __builtin_fmaxf(__x, __y); }
00547 
00548   inline long double
00549   fmax(long double __x, long double __y)
00550   { return __builtin_fmaxl(__x, __y); }
00551 
00552   template<typename _Tp, typename _Up>
00553     inline typename __promote_2<_Tp, _Up>::__type
00554     fmax(_Tp __x, _Up __y)
00555     {
00556       typedef typename __promote_2<_Tp, _Up>::__type __type;
00557       return fmax(__type(__x), __type(__y));
00558     }
00559 
00560   inline float
00561   fmin(float __x, float __y)
00562   { return __builtin_fminf(__x, __y); }
00563 
00564   inline long double
00565   fmin(long double __x, long double __y)
00566   { return __builtin_fminl(__x, __y); }
00567 
00568   template<typename _Tp, typename _Up>
00569     inline typename __promote_2<_Tp, _Up>::__type
00570     fmin(_Tp __x, _Up __y)
00571     {
00572       typedef typename __promote_2<_Tp, _Up>::__type __type;
00573       return fmin(__type(__x), __type(__y));
00574     }
00575 
00576   using std::fmod;
00577   using std::frexp;
00578 
00579   inline float
00580   hypot(float __x, float __y)
00581   { return __builtin_hypotf(__x, __y); }
00582 
00583   inline long double
00584   hypot(long double __x, long double __y)
00585   { return __builtin_hypotl(__x, __y); }
00586 
00587   template<typename _Tp, typename _Up>
00588     inline typename __promote_2<_Tp, _Up>::__type
00589     hypot(_Tp __x, _Up __y)
00590     {
00591       typedef typename __promote_2<_Tp, _Up>::__type __type;
00592       return hypot(__type(__x), __type(__y));
00593     }
00594 
00595   inline int
00596   ilogb(float __x)
00597   { return __builtin_ilogbf(__x); }
00598 
00599   inline int
00600   ilogb(long double __x)
00601   { return __builtin_ilogbl(__x); }
00602 
00603   template<typename _Tp>
00604     inline int
00605     ilogb(_Tp __x)
00606     {
00607       typedef typename __promote<_Tp>::__type __type;
00608       return ilogb(__type(__x));
00609     }
00610 
00611   using std::ldexp;
00612 
00613   inline float
00614   lgamma(float __x)
00615   { return __builtin_lgammaf(__x); }
00616 
00617   inline long double
00618   lgamma(long double __x)
00619   { return __builtin_lgammal(__x); }
00620 
00621   template<typename _Tp>
00622     inline typename __promote<_Tp>::__type 
00623     lgamma(_Tp __x)
00624     {
00625       typedef typename __promote<_Tp>::__type __type;
00626       return lgamma(__type(__x));
00627     }
00628 
00629   inline long long
00630   llrint(float __x)
00631   { return __builtin_llrintf(__x); }
00632 
00633   inline long long
00634   llrint(long double __x)
00635   { return __builtin_llrintl(__x); }
00636 
00637   template<typename _Tp>
00638     inline long long
00639     llrint(_Tp __x)
00640     {
00641       typedef typename __promote<_Tp>::__type __type;
00642       return llrint(__type(__x));
00643     }
00644 
00645   inline long long
00646   llround(float __x)
00647   { return __builtin_llroundf(__x); }
00648 
00649   inline long long
00650   llround(long double __x)
00651   { return __builtin_llroundl(__x); }
00652 
00653   template<typename _Tp>
00654     inline long long
00655     llround(_Tp __x)
00656     {
00657       typedef typename __promote<_Tp>::__type __type;
00658       return llround(__type(__x));
00659     }
00660 
00661   using std::log;
00662   using std::log10;
00663 
00664   inline float
00665   log1p(float __x)
00666   { return __builtin_log1pf(__x); }
00667 
00668   inline long double
00669   log1p(long double __x)
00670   { return __builtin_log1pl(__x); }
00671 
00672   template<typename _Tp>
00673     inline typename __promote<_Tp>::__type 
00674     log1p(_Tp __x)
00675     {
00676       typedef typename __promote<_Tp>::__type __type;
00677       return log1p(__type(__x));
00678     }
00679 
00680   // DR 568.
00681   inline float
00682   log2(float __x)
00683   { return __builtin_log2f(__x); }
00684 
00685   inline long double
00686   log2(long double __x)
00687   { return __builtin_log2l(__x); }
00688 
00689   template<typename _Tp>
00690     inline typename __promote<_Tp>::__type 
00691     log2(_Tp __x)
00692     {
00693       typedef typename __promote<_Tp>::__type __type;
00694       return log2(__type(__x));
00695     }
00696 
00697   inline float
00698   logb(float __x)
00699   { return __builtin_logbf(__x); }
00700 
00701   inline long double
00702   logb(long double __x)
00703   { return __builtin_logbl(__x); }
00704 
00705   template<typename _Tp>
00706     inline typename __promote<_Tp>::__type 
00707     logb(_Tp __x)
00708     {
00709       typedef typename __promote<_Tp>::__type __type;
00710       return logb(__type(__x));
00711     }
00712 
00713   inline long
00714   lrint(float __x)
00715   { return __builtin_lrintf(__x); }
00716 
00717   inline long
00718   lrint(long double __x)
00719   { return __builtin_lrintl(__x); }
00720 
00721   template<typename _Tp>
00722     inline long
00723     lrint(_Tp __x)
00724     {
00725       typedef typename __promote<_Tp>::__type __type;
00726       return lrint(__type(__x));
00727     }
00728 
00729   inline long
00730   lround(float __x)
00731   { return __builtin_lroundf(__x); }
00732 
00733   inline long
00734   lround(long double __x)
00735   { return __builtin_lroundl(__x); }
00736 
00737   template<typename _Tp>
00738     inline long
00739     lround(_Tp __x)
00740     {
00741       typedef typename __promote<_Tp>::__type __type;
00742       return lround(__type(__x));
00743     }
00744 
00745   inline float
00746   nearbyint(float __x)
00747   { return __builtin_nearbyintf(__x); }
00748 
00749   inline long double
00750   nearbyint(long double __x)
00751   { return __builtin_nearbyintl(__x); }
00752 
00753   template<typename _Tp>
00754     inline typename __promote<_Tp>::__type 
00755     nearbyint(_Tp __x)
00756     {
00757       typedef typename __promote<_Tp>::__type __type;
00758       return nearbyint(__type(__x));
00759     }
00760 
00761   inline float
00762   nextafter(float __x, float __y)
00763   { return __builtin_nextafterf(__x, __y); }
00764 
00765   inline long double
00766   nextafter(long double __x, long double __y)
00767   { return __builtin_nextafterl(__x, __y); }
00768 
00769   template<typename _Tp, typename _Up>
00770     inline typename __promote_2<_Tp, _Up>::__type
00771     nextafter(_Tp __x, _Up __y)
00772     {
00773       typedef typename __promote_2<_Tp, _Up>::__type __type;
00774       return nextafter(__type(__x), __type(__y));
00775     }
00776 
00777   inline float
00778   nexttoward(float __x, long double __y)
00779   { return __builtin_nexttowardf(__x, __y); }
00780 
00781   inline long double
00782   nexttoward(long double __x, long double __y)
00783   { return __builtin_nexttowardl(__x, __y); }
00784 
00785   template<typename _Tp>
00786     inline typename __promote<_Tp>::__type
00787     nexttoward(_Tp __x, long double __y)
00788     {
00789       typedef typename __promote<_Tp>::__type __type;
00790       return nexttoward(__type(__x), __y);
00791     }
00792 
00793   using std::pow;
00794 
00795   // DR 550.
00796   template<typename _Tp, typename _Up>
00797     inline typename __promote_2<_Tp, _Up>::__type
00798     pow(_Tp __x, _Up __y)
00799     {
00800       typedef typename __promote_2<_Tp, _Up>::__type __type;
00801       return pow(__type(__x), __type(__y));
00802     }
00803 
00804   inline float
00805   remainder(float __x, float __y)
00806   { return __builtin_remainderf(__x, __y); }
00807 
00808   inline long double
00809   remainder(long double __x, long double __y)
00810   { return __builtin_remainderl(__x, __y); }
00811 
00812   template<typename _Tp, typename _Up>
00813     inline typename __promote_2<_Tp, _Up>::__type
00814     remainder(_Tp __x, _Up __y)
00815     {
00816       typedef typename __promote_2<_Tp, _Up>::__type __type;
00817       return remainder(__type(__x), __type(__y));
00818     }
00819 
00820   inline float
00821   remquo(float __x, float __y, int* __pquo)
00822   { return __builtin_remquof(__x, __y, __pquo); }
00823 
00824   inline long double
00825   remquo(long double __x, long double __y, int* __pquo)
00826   { return __builtin_remquol(__x, __y, __pquo); }
00827 
00828   template<typename _Tp, typename _Up>
00829     inline typename __promote_2<_Tp, _Up>::__type
00830     remquo(_Tp __x, _Up __y, int* __pquo)
00831     {
00832       typedef typename __promote_2<_Tp, _Up>::__type __type;
00833       return remquo(__type(__x), __type(__y), __pquo);
00834     }
00835 
00836   inline float
00837   rint(float __x)
00838   { return __builtin_rintf(__x); }
00839 
00840   inline long double
00841   rint(long double __x)
00842   { return __builtin_rintl(__x); }
00843 
00844   template<typename _Tp>
00845     inline typename __promote<_Tp>::__type
00846     rint(_Tp __x)
00847     {
00848       typedef typename __promote<_Tp>::__type __type;
00849       return rint(__type(__x));
00850     }
00851 
00852   inline float
00853   round(float __x)
00854   { return __builtin_roundf(__x); }
00855 
00856   inline long double
00857   round(long double __x)
00858   { return __builtin_roundl(__x); }
00859 
00860   template<typename _Tp>
00861     inline typename __promote<_Tp>::__type
00862     round(_Tp __x)
00863     {
00864       typedef typename __promote<_Tp>::__type __type;
00865       return round(__type(__x));
00866     }
00867 
00868   inline float
00869   scalbln(float __x, long __ex)
00870   { return __builtin_scalblnf(__x, __ex); }
00871 
00872   inline long double
00873   scalbln(long double __x, long __ex)
00874   { return __builtin_scalblnl(__x, __ex); }
00875 
00876   template<typename _Tp>
00877     inline typename __promote<_Tp>::__type 
00878     scalbln(_Tp __x, long __ex)
00879     {
00880       typedef typename __promote<_Tp>::__type __type;
00881       return scalbln(__type(__x), __ex);
00882     }
00883  
00884   inline float
00885   scalbn(float __x, int __ex)
00886   { return __builtin_scalbnf(__x, __ex); }
00887 
00888   inline long double
00889   scalbn(long double __x, int __ex)
00890   { return __builtin_scalbnl(__x, __ex); }
00891 
00892   template<typename _Tp>
00893     inline typename __promote<_Tp>::__type 
00894     scalbn(_Tp __x, int __ex)
00895     {
00896       typedef typename __promote<_Tp>::__type __type;
00897       return scalbn(__type(__x), __ex);
00898     }
00899 
00900   using std::sin;
00901   using std::sinh;
00902   using std::sqrt;
00903   using std::tan;
00904   using std::tanh;
00905 
00906   inline float
00907   tgamma(float __x)
00908   { return __builtin_tgammaf(__x); }
00909 
00910   inline long double
00911   tgamma(long double __x)
00912   { return __builtin_tgammal(__x); }
00913 
00914   template<typename _Tp>
00915     inline typename __promote<_Tp>::__type 
00916     tgamma(_Tp __x)
00917     {
00918       typedef typename __promote<_Tp>::__type __type;
00919       return tgamma(__type(__x));
00920     }
00921  
00922   inline float
00923   trunc(float __x)
00924   { return __builtin_truncf(__x); }
00925 
00926   inline long double
00927   trunc(long double __x)
00928   { return __builtin_truncl(__x); }
00929 
00930   template<typename _Tp>
00931     inline typename __promote<_Tp>::__type 
00932     trunc(_Tp __x)
00933     {
00934       typedef typename __promote<_Tp>::__type __type;
00935       return trunc(__type(__x));
00936     }
00937 
00938 #endif
00939 
00940 _GLIBCXX_END_NAMESPACE
00941 }
00942 
00943 #endif