[Boost-commit] svn:boost r46217 - in trunk: boost/units boost/units/detail libs/units/test

From: steven_at_[hidden]
Date: 2008-06-07 13:15:24

Author: steven_watanabe
Date: 2008-06-07 13:15:24 EDT (Sat, 07 Jun 2008)
New Revision: 46217
URL: http://svn.boost.org/trac/boost/changeset/46217

Log:
Remove compiler specific code from cmath.  Disable functions which cannot be implemented easily using Boost.Math
Text files modified: 
   trunk/boost/units/cmath.hpp             |    29 ++++++-                                 
   trunk/boost/units/detail/cmath_impl.hpp |   145 +++++++++++++++++++++++++++++++++++++++ 
   trunk/libs/units/test/test_cmath.cpp    |    17 +++-                                    
   3 files changed, 179 insertions(+), 12 deletions(-)

Modified: trunk/boost/units/cmath.hpp
==============================================================================
--- trunk/boost/units/cmath.hpp	(original)
+++ trunk/boost/units/cmath.hpp	2008-06-07 13:15:24 EDT (Sat, 07 Jun 2008)
@@ -13,7 +13,9 @@
 
 #include <boost/version.hpp>
 
-#if (BOOST_VERSION <= 103500)
+// The trunk still has BOOST_VERSION == 103500
+//#if (BOOST_VERSION <= 103500)
+#if 0
     #include <boost/units/detail/cmath_boost_1_35.hpp>
 #else
 
@@ -21,9 +23,10 @@
 #include <cstdlib>
 
 #include <boost/math/special_functions/fpclassify.hpp>
-#include <boost/math/special_functions/sign.hpp>
 #include <boost/math/special_functions/hypot.hpp>
+#include <boost/math/special_functions/next.hpp>
 #include <boost/math/special_functions/round.hpp>
+#include <boost/math/special_functions/sign.hpp>
 
 #include <boost/units/dimensionless_quantity.hpp>
 #include <boost/units/pow.hpp>
@@ -220,6 +223,8 @@
     return quantity_type::from_value(fdim BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
 }
 
+#if 0
+
 template<class Unit1,class Unit2,class Unit3,class Y>
 inline 
 typename add_typeof_helper<
@@ -242,6 +247,8 @@
     return quantity_type::from_value(fma BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value(),q3.value()));
 }
 
+#endif
+
 template<class Unit,class Y>
 inline 
 quantity<Unit,Y> 
@@ -326,6 +333,8 @@
 //    return quantity_type::from_value(llround BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
 //}
 
+#if 0
+
 template<class Unit,class Y>
 inline 
 quantity<Unit,Y> 
@@ -338,30 +347,36 @@
     return quantity_type::from_value(nearbyint BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
 }
 
+#endif
+
 template<class Unit,class Y>
 inline 
 quantity<Unit,Y> nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
                                                              const quantity<Unit,Y>& q2)
 {
-    using namespace detail;
+    using boost::math::nextafter;
 
     typedef quantity<Unit,Y>    quantity_type;
     
     return quantity_type::from_value(nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
 }
-
 template<class Unit,class Y>
 inline 
 quantity<Unit,Y> nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION (const quantity<Unit,Y>& q1,
                                                               const quantity<Unit,Y>& q2)
 {
-    using namespace detail;
+    // the only difference between nextafter and nexttowards is
+    // in the argument types.  Since we are requiring identical
+    // argument types, there is no difference.
+    using boost::math::nextafter;
 
     typedef quantity<Unit,Y>    quantity_type;
     
-    return quantity_type::from_value(nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
+    return quantity_type::from_value(nextafter BOOST_PREVENT_MACRO_SUBSTITUTION (q1.value(),q2.value()));
 }
 
+#if 0
+
 template<class Unit,class Y>
 inline 
 quantity<Unit,Y> 
@@ -374,6 +389,8 @@
     return quantity_type::from_value(rint BOOST_PREVENT_MACRO_SUBSTITUTION (q.value()));
 }
 
+#endif
+
 template<class Unit,class Y>
 inline 
 quantity<Unit,Y> 

Modified: trunk/boost/units/detail/cmath_impl.hpp
==============================================================================
--- trunk/boost/units/detail/cmath_impl.hpp	(original)
+++ trunk/boost/units/detail/cmath_impl.hpp	2008-06-07 13:15:24 EDT (Sat, 07 Jun 2008)
@@ -13,14 +13,157 @@
 
 #include <boost/version.hpp>
 
-#if (BOOST_VERSION <= 103500)
+#if 0
+//#if (BOOST_VERSION <= 103500)
     #include <boost/units/detail/cmath_gnu_impl_boost_1_35.hpp>
     #include <boost/units/detail/cmath_mwcw_impl_boost_1_35.hpp>
     #include <boost/units/detail/cmath_msvc_impl_boost_1_35.hpp>
 #else
+#if 0
     #include <boost/units/detail/cmath_gnu_impl.hpp>
     #include <boost/units/detail/cmath_mwcw_impl.hpp>
     #include <boost/units/detail/cmath_msvc_impl.hpp>
+# endif
+
+#include <boost/math/special_functions/fpclassify.hpp>
+
+namespace boost {
+namespace units {
+namespace detail {
+
+template<class Y> 
+inline bool isgreater(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
+    else return v1 > v2;
+}
+
+template<class Y> 
+inline bool isgreaterequal(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
+    else return v1 >= v2;
+}
+
+template<class Y> 
+inline bool isless(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
+    else return v1 < v2;
+}
+
+template<class Y> 
+inline bool islessequal(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
+    else return v1 <= v2;
+}
+
+template<class Y> 
+inline bool islessgreater(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
+    else return v1 < v2 || v1 > v2;
+}
+
+template<class Y> 
+inline bool isunordered(const Y& v1,const Y& v2)
+{
+    return (boost::math::isnan)(v1) || (boost::math::isnan)(v2);
+}
+
+template<class Y>
+inline Y fdim(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1)) return v1;
+    else if((boost::math::isnan)(v2)) return v2;
+    else if(v1 > v2) return(v1 - v2);
+    else return(Y(0));
+}
+
+#if 0
+
+template<class T>
+struct fma_issue_warning {
+    enum { value = false };
+};
+
+template<class Y>
+inline Y fma(const Y& v1,const Y& v2,const Y& v3)
+{
+    //this implementation does *not* meet the
+    //requirement of infinite intermediate precision
+    BOOST_STATIC_WARNING((fma_issue_warning<Y>::value));
+
+    return v1 * v2 + v3;
+}
+
+#endif
+
+template<class Y>
+inline Y fmax(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1)) return(v2);
+    else if((boost::math::isnan)(v2)) return(v1);
+    else if(v1 > v2) return(v1);
+    else return(v2);
+}
+
+template<class Y>
+inline Y fmin(const Y& v1,const Y& v2)
+{
+    if((boost::math::isnan)(v1)) return(v2);
+    else if((boost::math::isnan)(v2)) return(v1);
+    else if(v1 < v2) return(v1);
+    else return(v2);
+}
+
+//template<class Y>
+//inline long long llrint(const Y& val)
+//{
+//    return static_cast<long long>(rint(val));
+//}
+//
+//template<class Y>
+//inline long long llround(const Y& val)
+//{
+//    return static_cast<long long>(round(val));
+//}
+
+#if 0
+
+template<class Y>
+inline Y nearbyint(const Y& val)
+{
+    //this is not really correct.
+    //the result should be according to the
+    //current rounding mode.
+    using boost::math::round;
+    return round(val);
+}
+
+template<class Y>
+inline Y rint(const Y& val)
+{
+    //I don't feel like trying to figure out
+    //how to raise a floating pointer exception
+    return nearbyint(val);
+}
+
+#endif
+
+template<class Y>
+inline Y trunc(const Y& val)
+{
+    if(val > 0) return std::floor(val);
+    else if(val < 0) return std::ceil(val);
+    else return val;
+}
+
+}
+}
+}
+
 #endif // (BOOST_VERSION <= 103500)
 
 #endif // BOOST_UNITS_CMATH_IMPL_HPP

Modified: trunk/libs/units/test/test_cmath.cpp
==============================================================================
--- trunk/libs/units/test/test_cmath.cpp	(original)
+++ trunk/libs/units/test/test_cmath.cpp	2008-06-07 13:15:24 EDT (Sat, 07 Jun 2008)
@@ -108,8 +108,10 @@
                                     L2(4.0*bu::meters);
     const bu::quantity<bu::area>    A1(4.0*bu::square_meters),
                                     A2(L1*L2+A1);
-    
+
+#if 0
     BOOST_CHECK((bu::fma)(L1,L2,A1) == A2);
+#endif
        
     BOOST_CHECK((bu::fmax)(E4,E5) == E5);
     BOOST_CHECK((bu::fmin)(E4,E5) == E4);
@@ -118,15 +120,20 @@
     
     BOOST_CHECK(bu::hypot(L1,L2) == 5.0*bu::meters);
     
+#if 0
+
 //    BOOST_CHECK(bu::llrint(E4).value() == bu::detail::llrint(E4.value()));
 //    BOOST_CHECK(bu::llround(E4).value() == bu::detail::llround(E4.value()));
     BOOST_CHECK((bu::nearbyint)(E4).value() == (bu::detail::nearbyint)(E4.value()));
     BOOST_CHECK((bu::rint)(E4).value() == (bu::detail::rint)(E4.value()));
 
-    BOOST_CHECK((bu::nextafter)(E4,E5).value() == (bu::detail::nextafter)(E4.value(),E5.value()));
-    BOOST_CHECK((bu::nextafter)(E5,E4).value() == (bu::detail::nextafter)(E5.value(),E4.value()));
-    BOOST_CHECK((bu::nexttoward)(E4,E5).value() == (bu::detail::nexttoward)(E4.value(),E5.value()));
-    BOOST_CHECK((bu::nexttoward)(E5,E4).value() == (bu::detail::nexttoward)(E5.value(),E4.value()));
+#endif
+
+    BOOST_CHECK((bu::nextafter)(E4,E5).value() == (boost::math::nextafter)(E4.value(),E5.value()));
+    BOOST_CHECK((bu::nextafter)(E5,E4).value() == (boost::math::nextafter)(E5.value(),E4.value()));
+
+    BOOST_CHECK((bu::nexttoward)(E4,E5).value() == (boost::math::nextafter)(E4.value(),E5.value()));
+    BOOST_CHECK((bu::nexttoward)(E5,E4).value() == (boost::math::nextafter)(E5.value(),E4.value()));
 
     BOOST_CHECK((bu::round)(E4 - 0.00000000001 * bu::joules) == -3.0*bu::joules);
     BOOST_CHECK((bu::round)(E5 + 0.00000000001 * bu::joules) == 3.0*bu::joules);