From 48e179266b514aebfa0a2e8e9508ce5cd8604bda Mon Sep 17 00:00:00 2001
From: John Maddock <john@johnmaddock.co.uk>
Date: Wed, 12 Oct 2011 11:06:09 +0000
Subject: [PATCH] Fix error checking for trunc and round functions. Update
 tests to match.

[SVN r74925]
---
 .../boost/math/special_functions/round.hpp    |  6 +-
 .../boost/math/special_functions/trunc.hpp    |  6 +-
 test/test_round.cpp                           | 68 ++++++++++++++++++-
 3 files changed, 73 insertions(+), 7 deletions(-)

diff --git a/include/boost/math/special_functions/round.hpp b/include/boost/math/special_functions/round.hpp
index 4ea2eaa08..f11c6aeb1 100644
--- a/include/boost/math/special_functions/round.hpp
+++ b/include/boost/math/special_functions/round.hpp
@@ -43,7 +43,7 @@ inline int iround(const T& v, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    T r = boost::math::round(v, pol);
-   if(fabs(r) > (std::numeric_limits<int>::max)())
+   if((r > (std::numeric_limits<int>::max)()) || (r < (std::numeric_limits<int>::min)()))
       return static_cast<int>(policies::raise_rounding_error("boost::math::iround<%1%>(%1%)", 0, v, 0, pol));
    return static_cast<int>(r);
 }
@@ -58,7 +58,7 @@ inline long lround(const T& v, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    T r = boost::math::round(v, pol);
-   if(fabs(r) > (std::numeric_limits<long>::max)())
+   if((r > (std::numeric_limits<long>::max)()) || (r < (std::numeric_limits<long>::min)()))
       return static_cast<long int>(policies::raise_rounding_error("boost::math::lround<%1%>(%1%)", 0, v, 0L, pol));
    return static_cast<long int>(r);
 }
@@ -75,7 +75,7 @@ inline boost::long_long_type llround(const T& v, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    T r = boost::math::round(v, pol);
-   if(fabs(r) > (std::numeric_limits<boost::long_long_type>::max)())
+   if((r > (std::numeric_limits<boost::long_long_type>::max)()) || (r < (std::numeric_limits<boost::long_long_type>::min)()))
       return static_cast<boost::long_long_type>(policies::raise_rounding_error("boost::math::llround<%1%>(%1%)", 0, v, 0LL, pol));
    return static_cast<boost::long_long_type>(r);
 }
diff --git a/include/boost/math/special_functions/trunc.hpp b/include/boost/math/special_functions/trunc.hpp
index f1702aea1..520ae89f5 100644
--- a/include/boost/math/special_functions/trunc.hpp
+++ b/include/boost/math/special_functions/trunc.hpp
@@ -43,7 +43,7 @@ inline int itrunc(const T& v, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    T r = boost::math::trunc(v, pol);
-   if(fabs(r) > (std::numeric_limits<int>::max)())
+   if((r > (std::numeric_limits<int>::max)()) || (r < (std::numeric_limits<int>::min)()))
       return static_cast<int>(policies::raise_rounding_error("boost::math::itrunc<%1%>(%1%)", 0, v, 0, pol));
    return static_cast<int>(r);
 }
@@ -58,7 +58,7 @@ inline long ltrunc(const T& v, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    T r = boost::math::trunc(v, pol);
-   if(fabs(r) > (std::numeric_limits<long>::max)())
+   if((r > (std::numeric_limits<long>::max)()) || (r < (std::numeric_limits<long>::min)()))
       return static_cast<long>(policies::raise_rounding_error("boost::math::ltrunc<%1%>(%1%)", 0, v, 0L, pol));
    return static_cast<long>(r);
 }
@@ -75,7 +75,7 @@ inline boost::long_long_type lltrunc(const T& v, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    T r = boost::math::trunc(v, pol);
-   if(fabs(r) > (std::numeric_limits<boost::long_long_type>::max)())
+   if((r > (std::numeric_limits<boost::long_long_type>::max)()) || (r < (std::numeric_limits<boost::long_long_type>::min)()))
       return static_cast<boost::long_long_type>(policies::raise_rounding_error("boost::math::lltrunc<%1%>(%1%)", 0, v, 0LL, pol));
    return static_cast<boost::long_long_type>(r);
 }
diff --git a/test/test_round.cpp b/test/test_round.cpp
index 6f16b3d1e..31ca653a1 100644
--- a/test/test_round.cpp
+++ b/test/test_round.cpp
@@ -145,7 +145,17 @@ void test_round(T, const char* name )
          r = boost::math::modf(arg, &i);
          check_modf_result(arg, r, i);
       }
-
+      if(std::numeric_limits<T>::digits >= std::numeric_limits<int>::digits)
+      {
+         int si = boost::math::iround(static_cast<T>((std::numeric_limits<int>::max)()));
+         check_within_half(static_cast<T>((std::numeric_limits<int>::max)()), si);
+         si = boost::math::iround(static_cast<T>((std::numeric_limits<int>::min)()));
+         check_within_half(static_cast<T>((std::numeric_limits<int>::min)()), si);
+         si = boost::math::itrunc(static_cast<T>((std::numeric_limits<int>::max)()));
+         check_trunc_result(static_cast<T>((std::numeric_limits<int>::max)()), si);
+         si = boost::math::itrunc(static_cast<T>((std::numeric_limits<int>::min)()));
+         check_trunc_result(static_cast<T>((std::numeric_limits<int>::min)()), si);
+      }
       if(abs(r) < (std::numeric_limits<long>::max)())
       {
          long l = boost::math::lround(arg);
@@ -155,6 +165,17 @@ void test_round(T, const char* name )
          r = boost::math::modf(arg, &l);
          check_modf_result(arg, r, l);
       }
+      if(std::numeric_limits<T>::digits >= std::numeric_limits<long>::digits)
+      {
+         long k = boost::math::lround(static_cast<T>((std::numeric_limits<long>::max)()));
+         check_within_half(static_cast<T>((std::numeric_limits<long>::max)()), k);
+         k = boost::math::lround(static_cast<T>((std::numeric_limits<long>::min)()));
+         check_within_half(static_cast<T>((std::numeric_limits<long>::min)()), k);
+         k = boost::math::ltrunc(static_cast<T>((std::numeric_limits<long>::max)()));
+         check_trunc_result(static_cast<T>((std::numeric_limits<long>::max)()), k);
+         k = boost::math::ltrunc(static_cast<T>((std::numeric_limits<long>::min)()));
+         check_trunc_result(static_cast<T>((std::numeric_limits<long>::min)()), k);
+      }
 
 #ifdef BOOST_HAS_LONG_LONG
       if(abs(r) < (std::numeric_limits<boost::long_long_type>::max)())
@@ -166,6 +187,17 @@ void test_round(T, const char* name )
          r = boost::math::modf(arg, &ll);
          check_modf_result(arg, r, ll);
       }
+      if(std::numeric_limits<T>::digits >= std::numeric_limits<boost::long_long_type>::digits)
+      {
+         boost::long_long_type j = boost::math::llround(static_cast<T>((std::numeric_limits<boost::long_long_type>::max)()));
+         check_within_half(static_cast<T>((std::numeric_limits<boost::long_long_type>::max)()), j);
+         j = boost::math::llround(static_cast<T>((std::numeric_limits<boost::long_long_type>::min)()));
+         check_within_half(static_cast<T>((std::numeric_limits<boost::long_long_type>::min)()), j);
+         j = boost::math::lltrunc(static_cast<T>((std::numeric_limits<boost::long_long_type>::max)()));
+         check_trunc_result(static_cast<T>((std::numeric_limits<boost::long_long_type>::max)()), j);
+         j = boost::math::lltrunc(static_cast<T>((std::numeric_limits<boost::long_long_type>::min)()));
+         check_trunc_result(static_cast<T>((std::numeric_limits<boost::long_long_type>::min)()), j);
+      }
 #endif
    }
    //
@@ -229,6 +261,40 @@ void test_round(T, const char* name )
       BOOST_CHECK_THROW(boost::math::lltrunc(std::numeric_limits<T>::quiet_NaN()), boost::math::rounding_error);
    #endif
    }
+   if(std::numeric_limits<T>::digits >= std::numeric_limits<int>::digits)
+   {
+      BOOST_CHECK_THROW(boost::math::itrunc(static_cast<T>((std::numeric_limits<int>::max)()) + 1), boost::math::rounding_error);
+      BOOST_CHECK_THROW(boost::math::itrunc(static_cast<T>((std::numeric_limits<int>::min)()) - 1), boost::math::rounding_error);
+   }
+   if(std::numeric_limits<T>::digits >= std::numeric_limits<long>::digits)
+   {
+      BOOST_CHECK_THROW(boost::math::ltrunc(static_cast<T>((std::numeric_limits<long>::max)()) + 1), boost::math::rounding_error);
+      BOOST_CHECK_THROW(boost::math::ltrunc(static_cast<T>((std::numeric_limits<long>::min)()) - 1), boost::math::rounding_error);
+   }
+#ifndef BOOST_NO_LONG_LONG
+   if(std::numeric_limits<T>::digits >= std::numeric_limits<boost::long_long_type>::digits)
+   {
+      BOOST_CHECK_THROW(boost::math::lltrunc(static_cast<T>((std::numeric_limits<boost::long_long_type>::max)()) + 1), boost::math::rounding_error);
+      BOOST_CHECK_THROW(boost::math::lltrunc(static_cast<T>((std::numeric_limits<boost::long_long_type>::min)()) - 1), boost::math::rounding_error);
+   }
+#endif
+   if(std::numeric_limits<T>::digits >= std::numeric_limits<int>::digits)
+   {
+      BOOST_CHECK_THROW(boost::math::iround(static_cast<T>((std::numeric_limits<int>::max)()) + 1), boost::math::rounding_error);
+      BOOST_CHECK_THROW(boost::math::iround(static_cast<T>((std::numeric_limits<int>::min)()) - 1), boost::math::rounding_error);
+   }
+   if(std::numeric_limits<T>::digits >= std::numeric_limits<long>::digits)
+   {
+      BOOST_CHECK_THROW(boost::math::lround(static_cast<T>((std::numeric_limits<long>::max)()) + 1), boost::math::rounding_error);
+      BOOST_CHECK_THROW(boost::math::lround(static_cast<T>((std::numeric_limits<long>::min)()) - 1), boost::math::rounding_error);
+   }
+#ifndef BOOST_NO_LONG_LONG
+   if(std::numeric_limits<T>::digits >= std::numeric_limits<boost::long_long_type>::digits)
+   {
+      BOOST_CHECK_THROW(boost::math::llround(static_cast<T>((std::numeric_limits<boost::long_long_type>::max)()) + 1), boost::math::rounding_error);
+      BOOST_CHECK_THROW(boost::math::llround(static_cast<T>((std::numeric_limits<boost::long_long_type>::min)()) - 1), boost::math::rounding_error);
+   }
+#endif
 }
 
 int test_main(int, char* [])