[Boost-commit] svn:boost r45216 - in sandbox/math_toolkit: boost/math/special_functions libs/math/test libs/math/test/compile_test

From: john_at_[hidden]
Date: 2008-05-08 12:16:52

Author: johnmaddock
Date: 2008-05-08 12:16:51 EDT (Thu, 08 May 2008)
New Revision: 45216
URL: http://svn.boost.org/trac/boost/changeset/45216

Log:
Renamed next_* functions to float_*.
Text files modified: 
   sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp         |    18 ++++++++--------                        
   sandbox/math_toolkit/boost/math/special_functions/next.hpp             |    44 ++++++++++++++++++++--------------------
   sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp       |    18 ++++++++--------                        
   sandbox/math_toolkit/libs/math/test/compile_test/sf_next_incl_test.cpp |    18 ++++++++--------                        
   sandbox/math_toolkit/libs/math/test/test_next.cpp                      |    34 +++++++++++++++---------------          
   5 files changed, 66 insertions(+), 66 deletions(-)

Modified: sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/math_fwd.hpp	2008-05-08 12:16:51 EDT (Thu, 08 May 2008)
@@ -685,17 +685,17 @@
    template <class T>
    T nextafter(const T&, const T&);
    template <class T, class Policy>
-   T next_greater(const T&, const Policy&);
+   T float_next(const T&, const Policy&);
    template <class T>
-   T next_greater(const T&);
+   T float_next(const T&);
    template <class T, class Policy>
-   T next_less(const T&, const Policy&);
+   T float_prior(const T&, const Policy&);
    template <class T>
-   T next_less(const T&);
+   T float_prior(const T&);
    template <class T, class Policy>
-   T edit_distance(const T&, const T&, const Policy&);
+   T float_distance(const T&, const T&, const Policy&);
    template <class T>
-   T edit_distance(const T&, const T&);
+   T float_distance(const T&, const T&);
 
     } // namespace math
 } // namespace boost
@@ -1044,9 +1044,9 @@
    template <int N, class T>\
    inline typename boost::math::tools::promote_args<T>::type pow(T v){ return boost::math::pow<N>(v, Policy()); }\
    template <class T> T nextafter(const T& a, const T& b){ return boost::math::nextafter(a, b, Policy()); }\
-   template <class T> T next_greater(const T& a){ return boost::math::next_greater(a, Policy()); }\
-   template <class T> T next_less(const T& a){ return boost::math::next_less(a, Policy()); }\
-   template <class T> T edit_distance(const T& a, const T& b){ return boost::math::edit_distance(a, b, Policy()); }\
+   template <class T> T float_next(const T& a){ return boost::math::float_next(a, Policy()); }\
+   template <class T> T float_prior(const T& a){ return boost::math::float_prior(a, Policy()); }\
+   template <class T> T float_distance(const T& a, const T& b){ return boost::math::float_distance(a, b, Policy()); }\
 
 
 #endif // BOOST_MATH_SPECIAL_MATH_FWD_HPP

Modified: sandbox/math_toolkit/boost/math/special_functions/next.hpp
==============================================================================
--- sandbox/math_toolkit/boost/math/special_functions/next.hpp	(original)
+++ sandbox/math_toolkit/boost/math/special_functions/next.hpp	2008-05-08 12:16:51 EDT (Thu, 08 May 2008)
@@ -43,11 +43,11 @@
 }
 
 template <class T, class Policy>
-T next_greater(const T& val, const Policy& pol)
+T float_next(const T& val, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    int expon;
-   static const char* function = "next_greater<%1%>(%1%)";
+   static const char* function = "float_next<%1%>(%1%)";
 
    if(!(boost::math::isfinite)(val))
       return policies::raise_domain_error<T>(
@@ -70,9 +70,9 @@
 
 #ifdef BOOST_MSVC
 template <class Policy>
-inline double next_greater(const double& val, const Policy& pol)
+inline double float_next(const double& val, const Policy& pol)
 {
-   static const char* function = "next_greater<%1%>(%1%)";
+   static const char* function = "float_next<%1%>(%1%)";
 
    if(!(boost::math::isfinite)(val))
       return policies::raise_domain_error<double>(
@@ -87,17 +87,17 @@
 #endif
 
 template <class T>
-inline T next_greater(const T& val)
+inline T float_next(const T& val)
 {
-   return next_greater(val, policies::policy<>());
+   return float_next(val, policies::policy<>());
 }
 
 template <class T, class Policy>
-T next_less(const T& val, const Policy& pol)
+T float_prior(const T& val, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    int expon;
-   static const char* function = "next_less<%1%>(%1%)";
+   static const char* function = "float_prior<%1%>(%1%)";
 
    if(!(boost::math::isfinite)(val))
       return policies::raise_domain_error<T>(
@@ -121,9 +121,9 @@
 
 #ifdef BOOST_MSVC
 template <class Policy>
-inline double next_less(const double& val, const Policy& pol)
+inline double float_prior(const double& val, const Policy& pol)
 {
-   static const char* function = "next_less<%1%>(%1%)";
+   static const char* function = "float_prior<%1%>(%1%)";
 
    if(!(boost::math::isfinite)(val))
       return policies::raise_domain_error<double>(
@@ -138,15 +138,15 @@
 #endif
 
 template <class T>
-inline T next_less(const T& val)
+inline T float_prior(const T& val)
 {
-   return next_less(val, policies::policy<>());
+   return float_prior(val, policies::policy<>());
 }
 
 template <class T, class Policy>
 inline T nextafter(const T& val, const T& direction, const Policy& pol)
 {
-   return val < direction ? boost::math::next_greater(val, pol) : val == direction ? val : boost::math::next_less(val, pol);
+   return val < direction ? boost::math::float_next(val, pol) : val == direction ? val : boost::math::float_prior(val, pol);
 }
 
 template <class T>
@@ -156,13 +156,13 @@
 }
 
 template <class T, class Policy>
-T edit_distance(const T& a, const T& b, const Policy& pol)
+T float_distance(const T& a, const T& b, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    //
    // Error handling:
    //
-   static const char* function = "edit_distance<%1%>(%1%, %1%)";
+   static const char* function = "float_distance<%1%>(%1%, %1%)";
    if(!(boost::math::isfinite)(a))
       return policies::raise_domain_error<T>(
          function,
@@ -177,18 +177,18 @@
    if(a == b)
       return 0;
    if(a == 0)
-      return 1 + edit_distance(boost::math::sign(b) * detail::get_smallest_value<T>(), b, pol);
+      return 1 + float_distance(boost::math::sign(b) * detail::get_smallest_value<T>(), b, pol);
    if(b == 0)
-      return 1 + edit_distance(boost::math::sign(a) * detail::get_smallest_value<T>(), a, pol);
+      return 1 + float_distance(boost::math::sign(a) * detail::get_smallest_value<T>(), a, pol);
    if(boost::math::sign(a) != boost::math::sign(b))
-      return 2 + edit_distance(boost::math::sign(b) * detail::get_smallest_value<T>(), b, pol)
-         + edit_distance(boost::math::sign(a) * detail::get_smallest_value<T>(), a, pol);
+      return 2 + float_distance(boost::math::sign(b) * detail::get_smallest_value<T>(), b, pol)
+         + float_distance(boost::math::sign(a) * detail::get_smallest_value<T>(), a, pol);
 
    if((std::min)(fabs(a), fabs(b)) / (std::max)(fabs(a), fabs(b)) < 2 * tools::epsilon<T>())
    {
       bool biga = fabs(a) > fabs(b);
       T split = ldexp(biga ? b : a, tools::digits<T>() - 2);
-      return edit_distance(a, split, pol) + edit_distance(split, b, pol);
+      return float_distance(a, split, pol) + float_distance(split, b, pol);
    }
 
    BOOST_MATH_STD_USING
@@ -229,9 +229,9 @@
 }
 
 template <class T>
-T edit_distance(const T& a, const T& b)
+T float_distance(const T& a, const T& b)
 {
-   return boost::math::edit_distance(a, b, policies::policy<>());
+   return boost::math::float_distance(a, b, policies::policy<>());
 }
 
 }} // namespaces

Modified: sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/instantiate.hpp	2008-05-08 12:16:51 EDT (Thu, 08 May 2008)
@@ -247,9 +247,9 @@
 #endif
    boost::math::pow<2>(v1);
    boost::math::nextafter(v1, v1);
-   boost::math::next_greater(v1);
-   boost::math::next_less(v1);
-   boost::math::edit_distance(v1, v1);
+   boost::math::float_next(v1);
+   boost::math::float_prior(v1);
+   boost::math::float_distance(v1, v1);
    //
    // All over again, with a policy this time:
    //
@@ -373,9 +373,9 @@
 #endif
    boost::math::pow<2>(v1, pol);
    boost::math::nextafter(v1, v1, pol);
-   boost::math::next_greater(v1, pol);
-   boost::math::next_less(v1, pol);
-   boost::math::edit_distance(v1, v1, pol);
+   boost::math::float_next(v1, pol);
+   boost::math::float_prior(v1, pol);
+   boost::math::float_distance(v1, v1, pol);
    //
    // All over again with the versions in test::
    //
@@ -492,9 +492,9 @@
 #endif
    test::pow<2>(v1);
    test::nextafter(v1, v1);
-   test::next_greater(v1);
-   test::next_less(v1);
-   test::edit_distance(v1, v1);
+   test::float_next(v1);
+   test::float_prior(v1);
+   test::float_distance(v1, v1);
 }
 
 template <class RealType>

Modified: sandbox/math_toolkit/libs/math/test/compile_test/sf_next_incl_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/compile_test/sf_next_incl_test.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/compile_test/sf_next_incl_test.cpp	2008-05-08 12:16:51 EDT (Thu, 08 May 2008)
@@ -21,22 +21,22 @@
    check_result<long double>(boost::math::nextafter<long double>(l, l));
 #endif
 
-   check_result<float>(boost::math::next_greater<float>(f));
-   check_result<double>(boost::math::next_greater<double>(d));
+   check_result<float>(boost::math::float_next<float>(f));
+   check_result<double>(boost::math::float_next<double>(d));
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-   check_result<long double>(boost::math::next_greater<long double>(l));
+   check_result<long double>(boost::math::float_next<long double>(l));
 #endif
 
-   check_result<float>(boost::math::next_less<float>(f));
-   check_result<double>(boost::math::next_less<double>(d));
+   check_result<float>(boost::math::float_prior<float>(f));
+   check_result<double>(boost::math::float_prior<double>(d));
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-   check_result<long double>(boost::math::next_less<long double>(l));
+   check_result<long double>(boost::math::float_prior<long double>(l));
 #endif
 
-   check_result<float>(boost::math::edit_distance<float>(f, f));
-   check_result<double>(boost::math::edit_distance<double>(d, d));
+   check_result<float>(boost::math::float_distance<float>(f, f));
+   check_result<double>(boost::math::float_distance<double>(d, d));
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-   check_result<long double>(boost::math::edit_distance<long double>(l, l));
+   check_result<long double>(boost::math::float_distance<long double>(l, l));
 #endif
 
 }

Modified: sandbox/math_toolkit/libs/math/test/test_next.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_next.cpp	(original)
+++ sandbox/math_toolkit/libs/math/test/test_next.cpp	2008-05-08 12:16:51 EDT (Thu, 08 May 2008)
@@ -17,20 +17,20 @@
 
    std::cout << "Testing type " << name << " with initial value " << val << std::endl;
 
-   BOOST_CHECK_EQUAL(edit_distance(next_greater(val), val), 1);
-   BOOST_CHECK(next_greater(val) > val);
-   BOOST_CHECK_EQUAL(edit_distance(next_less(val), val), 1);
-   BOOST_CHECK(next_less(val) < val);
-   BOOST_CHECK_EQUAL(edit_distance(nextafter(val, upper), val), 1);
+   BOOST_CHECK_EQUAL(float_distance(float_next(val), val), 1);
+   BOOST_CHECK(float_next(val) > val);
+   BOOST_CHECK_EQUAL(float_distance(float_prior(val), val), 1);
+   BOOST_CHECK(float_prior(val) < val);
+   BOOST_CHECK_EQUAL(float_distance(nextafter(val, upper), val), 1);
    BOOST_CHECK(nextafter(val, upper) > val);
-   BOOST_CHECK_EQUAL(edit_distance(nextafter(val, lower), val), 1);
+   BOOST_CHECK_EQUAL(float_distance(nextafter(val, lower), val), 1);
    BOOST_CHECK(nextafter(val, lower) < val);
-   BOOST_CHECK_EQUAL(edit_distance(next_greater(next_greater(val)), val), 2);
-   BOOST_CHECK_EQUAL(edit_distance(next_less(next_less(val)), val), 2);
-   BOOST_CHECK_EQUAL(edit_distance(next_less(next_greater(val)), val), 0);
-   BOOST_CHECK_EQUAL(edit_distance(next_greater(next_less(val)), val), 0);
-   BOOST_CHECK_EQUAL(next_less(next_greater(val)), val);
-   BOOST_CHECK_EQUAL(next_greater(next_less(val)), val);
+   BOOST_CHECK_EQUAL(float_distance(float_next(float_next(val)), val), 2);
+   BOOST_CHECK_EQUAL(float_distance(float_prior(float_prior(val)), val), 2);
+   BOOST_CHECK_EQUAL(float_distance(float_prior(float_next(val)), val), 0);
+   BOOST_CHECK_EQUAL(float_distance(float_next(float_prior(val)), val), 0);
+   BOOST_CHECK_EQUAL(float_prior(float_next(val)), val);
+   BOOST_CHECK_EQUAL(float_next(float_prior(val)), val);
 }
 
 template <class T>
@@ -82,17 +82,17 @@
       T v2 = val;
       for(unsigned j = 0; j < primes[i]; ++j)
       {
-         v1 = boost::math::next_greater(v1);
-         v2 = boost::math::next_less(v2);
+         v1 = boost::math::float_next(v1);
+         v2 = boost::math::float_prior(v2);
       }
-      BOOST_CHECK_EQUAL(boost::math::edit_distance(v1, val), primes[i]);
-      BOOST_CHECK_EQUAL(boost::math::edit_distance(v2, val), primes[i]);
+      BOOST_CHECK_EQUAL(boost::math::float_distance(v1, val), primes[i]);
+      BOOST_CHECK_EQUAL(boost::math::float_distance(v2, val), primes[i]);
    }
 }
 
 int test_main(int, char* [])
 {
-   std::cout << boost::math::edit_distance(1.0, 0.0) << std::endl;
+   std::cout << boost::math::float_distance(1.0, 0.0) << std::endl;
    test_values(1.0f, "float");
    test_values(1.0, "double");
    test_values(1.0L, "long double");