Changeset 44612


Ignore:
Timestamp:
Apr 20, 2008, 10:58:20 AM (10 years ago)
Author:
John Maddock
Message:

Moved real_concept and std_real_concept overloads of the rounding and truncation functions into the same namespace as the classes so that they can be found via ADL.
Updated the tests to cope with the change.
Updated library configuration to cope with the change.
Made sure that the rounding and truncation functions are all correctly forward declared.

Location:
trunk
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/boost/math/concepts/real_concept.hpp

    r44452 r44612  
    237237inline real_concept tanh(real_concept a)
    238238{ return std::tanh(a.value()); }
     239
     240//
     241// Conversion and truncation routines:
     242//
     243template <class Policy>
     244inline int iround(const concepts::real_concept& v, const Policy& pol)
     245{ return boost::math::iround(v.value(), pol); }
     246inline int iround(const concepts::real_concept& v)
     247{ return boost::math::iround(v.value(), policies::policy<>()); }
     248template <class Policy>
     249inline long lround(const concepts::real_concept& v, const Policy& pol)
     250{ return boost::math::lround(v.value(), pol); }
     251inline long lround(const concepts::real_concept& v)
     252{ return boost::math::lround(v.value(), policies::policy<>()); }
     253
     254#ifdef BOOST_HAS_LONG_LONG
     255template <class Policy>
     256inline long long llround(const concepts::real_concept& v, const Policy& pol)
     257{ return boost::math::llround(v.value(), pol); }
     258inline long long llround(const concepts::real_concept& v)
     259{ return boost::math::llround(v.value(), policies::policy<>()); }
     260#endif
     261
     262template <class Policy>
     263inline int itrunc(const concepts::real_concept& v, const Policy& pol)
     264{ return boost::math::itrunc(v.value(), pol); }
     265inline int itrunc(const concepts::real_concept& v)
     266{ return boost::math::itrunc(v.value(), policies::policy<>()); }
     267template <class Policy>
     268inline long ltrunc(const concepts::real_concept& v, const Policy& pol)
     269{ return boost::math::ltrunc(v.value(), pol); }
     270inline long ltrunc(const concepts::real_concept& v)
     271{ return boost::math::ltrunc(v.value(), policies::policy<>()); }
     272
     273#ifdef BOOST_HAS_LONG_LONG
     274template <class Policy>
     275inline long long lltrunc(const concepts::real_concept& v, const Policy& pol)
     276{ return boost::math::lltrunc(v.value(), pol); }
     277inline long long lltrunc(const concepts::real_concept& v)
     278{ return boost::math::lltrunc(v.value(), policies::policy<>()); }
     279#endif
    239280
    240281// Streaming:
     
    325366} // namespace tools
    326367
    327 //
    328 // Conversion and truncation routines:
    329 //
    330 template <class Policy>
    331 inline int iround(const concepts::real_concept& v, const Policy& pol)
    332 {
    333    return iround(v.value(), pol);
    334 }
    335 inline int iround(const concepts::real_concept& v)
    336 {
    337    return iround(v.value(), policies::policy<>());
    338 }
    339 
    340 template <class Policy>
    341 inline long lround(const concepts::real_concept& v, const Policy& pol)
    342 {
    343    return lround(v.value(), pol);
    344 }
    345 inline long lround(const concepts::real_concept& v)
    346 {
    347    return lround(v.value(), policies::policy<>());
    348 }
    349 
    350 #ifdef BOOST_HAS_LONG_LONG
    351 
    352 template <class Policy>
    353 inline long long llround(const concepts::real_concept& v, const Policy& pol)
    354 {
    355    return llround(v.value(), pol);
    356 }
    357 inline long long llround(const concepts::real_concept& v)
    358 {
    359    return llround(v.value(), policies::policy<>());
    360 }
    361 
    362 #endif
    363 
    364 template <class Policy>
    365 inline int itrunc(const concepts::real_concept& v, const Policy& pol)
    366 {
    367    return itrunc(v.value(), pol);
    368 }
    369 inline int itrunc(const concepts::real_concept& v)
    370 {
    371    return itrunc(v.value(), policies::policy<>());
    372 }
    373 
    374 template <class Policy>
    375 inline long ltrunc(const concepts::real_concept& v, const Policy& pol)
    376 {
    377    return ltrunc(v.value(), pol);
    378 }
    379 inline long ltrunc(const concepts::real_concept& v)
    380 {
    381    return ltrunc(v.value(), policies::policy<>());
    382 }
    383 
    384 #ifdef BOOST_HAS_LONG_LONG
    385 
    386 template <class Policy>
    387 inline long long lltrunc(const concepts::real_concept& v, const Policy& pol)
    388 {
    389    return lltrunc(v.value(), pol);
    390 }
    391 inline long long lltrunc(const concepts::real_concept& v)
    392 {
    393    return lltrunc(v.value(), policies::policy<>());
    394 }
    395 
    396 #endif
    397 
    398368#if defined(__SGI_STL_PORT)
    399369//
  • trunk/boost/math/concepts/std_real_concept.hpp

    r44091 r44612  
    224224namespace boost{ namespace math{ namespace concepts{
    225225
     226//
     227// Conversion and truncation routines:
     228//
     229template <class Policy>
     230inline int iround(const concepts::std_real_concept& v, const Policy& pol)
     231{
     232   return boost::math::iround(v.value(), pol);
     233}
     234inline int iround(const concepts::std_real_concept& v)
     235{
     236   return boost::math::iround(v.value(), policies::policy<>());
     237}
     238
     239template <class Policy>
     240inline long lround(const concepts::std_real_concept& v, const Policy& pol)
     241{
     242   return boost::math::lround(v.value(), pol);
     243}
     244inline long lround(const concepts::std_real_concept& v)
     245{
     246   return boost::math::lround(v.value(), policies::policy<>());
     247}
     248
     249#ifdef BOOST_HAS_LONG_LONG
     250
     251template <class Policy>
     252inline long long llround(const concepts::std_real_concept& v, const Policy& pol)
     253{
     254   return boost::math::llround(v.value(), pol);
     255}
     256inline long long llround(const concepts::std_real_concept& v)
     257{
     258   return boost::math::llround(v.value(), policies::policy<>());
     259}
     260
     261#endif
     262
     263template <class Policy>
     264inline int itrunc(const concepts::std_real_concept& v, const Policy& pol)
     265{
     266   return boost::math::itrunc(v.value(), pol);
     267}
     268inline int itrunc(const concepts::std_real_concept& v)
     269{
     270   return boost::math::itrunc(v.value(), policies::policy<>());
     271}
     272
     273template <class Policy>
     274inline long ltrunc(const concepts::std_real_concept& v, const Policy& pol)
     275{
     276   return boost::math::ltrunc(v.value(), pol);
     277}
     278inline long ltrunc(const concepts::std_real_concept& v)
     279{
     280   return boost::math::ltrunc(v.value(), policies::policy<>());
     281}
     282
     283#ifdef BOOST_HAS_LONG_LONG
     284
     285template <class Policy>
     286inline long long lltrunc(const concepts::std_real_concept& v, const Policy& pol)
     287{
     288   return boost::math::lltrunc(v.value(), pol);
     289}
     290inline long long lltrunc(const concepts::std_real_concept& v)
     291{
     292   return boost::math::lltrunc(v.value(), policies::policy<>());
     293}
     294
     295#endif
     296
    226297// Streaming:
    227298template <class charT, class traits>
     
    283354} // namespace tools
    284355
    285 //
    286 // Conversion and truncation routines:
    287 //
    288 template <class Policy>
    289 inline int iround(const concepts::std_real_concept& v, const Policy& pol)
    290 {
    291    return iround(v.value(), pol);
    292 }
    293 inline int iround(const concepts::std_real_concept& v)
    294 {
    295    return iround(v.value(), policies::policy<>());
    296 }
    297 
    298 template <class Policy>
    299 inline long lround(const concepts::std_real_concept& v, const Policy& pol)
    300 {
    301    return lround(v.value(), pol);
    302 }
    303 inline long lround(const concepts::std_real_concept& v)
    304 {
    305    return lround(v.value(), policies::policy<>());
    306 }
    307 
    308 #ifdef BOOST_HAS_LONG_LONG
    309 
    310 template <class Policy>
    311 inline long long llround(const concepts::std_real_concept& v, const Policy& pol)
    312 {
    313    return llround(v.value(), pol);
    314 }
    315 inline long long llround(const concepts::std_real_concept& v)
    316 {
    317    return llround(v.value(), policies::policy<>());
    318 }
    319 
    320 #endif
    321 
    322 template <class Policy>
    323 inline int itrunc(const concepts::std_real_concept& v, const Policy& pol)
    324 {
    325    return itrunc(v.value(), pol);
    326 }
    327 inline int itrunc(const concepts::std_real_concept& v)
    328 {
    329    return itrunc(v.value(), policies::policy<>());
    330 }
    331 
    332 template <class Policy>
    333 inline long ltrunc(const concepts::std_real_concept& v, const Policy& pol)
    334 {
    335    return ltrunc(v.value(), pol);
    336 }
    337 inline long ltrunc(const concepts::std_real_concept& v)
    338 {
    339    return ltrunc(v.value(), policies::policy<>());
    340 }
    341 
    342 #ifdef BOOST_HAS_LONG_LONG
    343 
    344 template <class Policy>
    345 inline long long lltrunc(const concepts::std_real_concept& v, const Policy& pol)
    346 {
    347    return lltrunc(v.value(), pol);
    348 }
    349 inline long long lltrunc(const concepts::std_real_concept& v)
    350 {
    351    return lltrunc(v.value(), policies::policy<>());
    352 }
    353 
    354 #endif
    355 
    356356} // namespace math
    357357} // namespace boost
  • trunk/boost/math/special_functions/math_fwd.hpp

    r44091 r44612  
    2424#endif
    2525
     26#include <boost/math/special_functions/detail/round_fwd.hpp>
    2627#include <boost/math/tools/promotion.hpp> // for argument promotion.
    2728#include <boost/math/policies/policy.hpp>
     
    657658   typename tools::promote_args<T>::type zeta(T s);
    658659
    659    template <class T, class Policy>
    660    T trunc(const T& v, const Policy& pol);
    661    template <class T>
    662    T trunc(const T& v);
    663    template <class T, class Policy>
    664    int itrunc(const T& v, const Policy& pol);
    665    template <class T>
    666    int itrunc(const T& v);
    667    template <class T, class Policy>
    668    long ltrunc(const T& v, const Policy& pol);
    669    template <class T>
    670    long ltrunc(const T& v);
    671 
    672 
    673660    } // namespace math
    674661} // namespace boost
     
    678665   \
    679666   template <class T>\
    680    inline T modf(const T& v, long long* ipart){ return boost::math::modf(v, ipart, Policy()); }\
    681    \
    682    template <class T>\
    683    inline long long lltrunc(const T& v){ return boost::math::lltrunc(v, Policy()); }\
    684    \
    685    template <class T>\
    686    inline long long llround(const T& v){ return boost::math::llround(v, Policy()); }\
     667   inline T modf(const T& v, long long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
     668   \
     669   template <class T>\
     670   inline long long lltrunc(const T& v){ using boost::math::lltrunc; return lltrunc(v, Policy()); }\
     671   \
     672   template <class T>\
     673   inline long long llround(const T& v){ using boost::math::llround; return llround(v, Policy()); }\
    687674
    688675#else
     
    989976   \
    990977   template <class T>\
    991    inline T round(const T& v){ return boost::math::round(v, Policy()); }\
    992    \
    993    template <class T>\
    994    inline int iround(const T& v){ return boost::math::iround(v, Policy()); }\
    995    \
    996    template <class T>\
    997    inline long lround(const T& v){ return boost::math::lround(v, Policy()); }\
    998    \
    999    template <class T>\
    1000    inline T trunc(const T& v){ return boost::math::trunc(v, Policy()); }\
    1001    \
    1002    template <class T>\
    1003    inline int itrunc(const T& v){ return boost::math::itrunc(v, Policy()); }\
    1004    \
    1005    template <class T>\
    1006    inline long ltrunc(const T& v){ return boost::math::ltrunc(v, Policy()); }\
    1007    \
    1008    template <class T>\
    1009    inline T modf(const T& v, T* ipart){ return boost::math::modf(v, ipart, Policy()); }\
    1010    \
    1011    template <class T>\
    1012    inline T modf(const T& v, int* ipart){ return boost::math::modf(v, ipart, Policy()); }\
    1013    \
    1014    template <class T>\
    1015    inline T modf(const T& v, long* ipart){ return boost::math::modf(v, ipart, Policy()); }\
     978   inline T round(const T& v){ using boost::math::round; return round(v, Policy()); }\
     979   \
     980   template <class T>\
     981   inline int iround(const T& v){ using boost::math::iround; return iround(v, Policy()); }\
     982   \
     983   template <class T>\
     984   inline long lround(const T& v){ using boost::math::lround; return lround(v, Policy()); }\
     985   \
     986   template <class T>\
     987   inline T trunc(const T& v){ using boost::math::trunc; return trunc(v, Policy()); }\
     988   \
     989   template <class T>\
     990   inline int itrunc(const T& v){ using boost::math::itrunc; return itrunc(v, Policy()); }\
     991   \
     992   template <class T>\
     993   inline long ltrunc(const T& v){ using boost::math::ltrunc; return ltrunc(v, Policy()); }\
     994   \
     995   template <class T>\
     996   inline T modf(const T& v, T* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
     997   \
     998   template <class T>\
     999   inline T modf(const T& v, int* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
     1000   \
     1001   template <class T>\
     1002   inline T modf(const T& v, long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
    10161003   \
    10171004   template <int N, class T>\
  • trunk/boost/math/tools/config.hpp

    r44091 r44612  
    2222
    2323#include <boost/math/tools/user.hpp>
     24#include <boost/math/special_functions/detail/round_fwd.hpp>
    2425
    2526#if defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__hppa)
     
    190191   using std::floor;\
    191192   using std::log10;\
    192    using std::sqrt;
     193   using std::sqrt;\
     194   using boost::math::round;\
     195   using boost::math::iround;\
     196   using boost::math::lround;\
     197   using boost::math::trunc;\
     198   using boost::math::itrunc;\
     199   using boost::math::ltrunc;\
     200   using boost::math::modf;
    193201
    194202
  • trunk/libs/math/test/compile_test/instantiate.hpp

    r44091 r44612  
    348348   boost::math::zeta(v1, pol);
    349349   boost::math::zeta(i, pol);
    350    boost::math::trunc(v1, pol);
    351    boost::math::itrunc(v1, pol);
    352    boost::math::ltrunc(v1, pol);
    353    boost::math::round(v1, pol);
    354    boost::math::iround(v1, pol);
    355    boost::math::lround(v1, pol);
    356    boost::math::modf(v1, &v1, pol);
    357    boost::math::modf(v1, &i, pol);
    358    boost::math::modf(v1, &l, pol);
     350   //
     351   // These next functions are intended to be found via ADL:
     352   //
     353   BOOST_MATH_STD_USING
     354   trunc(v1, pol);
     355   itrunc(v1, pol);
     356   ltrunc(v1, pol);
     357   round(v1, pol);
     358   iround(v1, pol);
     359   lround(v1, pol);
     360   modf(v1, &v1, pol);
     361   modf(v1, &i, pol);
     362   modf(v1, &l, pol);
    359363#ifdef BOOST_HAS_LONG_LONG
    360    boost::math::lltrunc(v1, pol);
    361    boost::math::llround(v1, pol);
    362    boost::math::modf(v1, &ll, pol);
     364   using boost::math::lltrunc;
     365   using boost::math::llround;
     366   lltrunc(v1, pol);
     367   llround(v1, pol);
     368   modf(v1, &ll, pol);
    363369#endif
    364370   boost::math::pow<2>(v1, pol);
Note: See TracChangeset for help on using the changeset viewer.