# tr1/cmath

Go to the documentation of this 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