Index: rational.hpp
===================================================================
--- rational.hpp	(revision 85565)
+++ rational.hpp	(working copy)
@@ -21,6 +21,8 @@
 //    Nickolay Mladenov, for the implementation of operator+=
 
 //  Revision History
+//  05 Sep 13  Added preliminary version of numeric_limits<> specialization
+//             (Adam Wulkiewicz)
 //  02 Sep 13  Remove unneeded forward declarations; tweak private helper
 //             function (Daryle Walker)
 //  30 Aug 13  Improve exception safety of "assign"; start modernizing I/O code
@@ -82,6 +84,7 @@
 #include <boost/math/common_factor_rt.hpp>  // for boost::math::gcd, lcm
 #include <limits>                // for std::numeric_limits
 #include <boost/static_assert.hpp>  // for BOOST_STATIC_ASSERT
+#include <boost/config.hpp>      // for BOOST_CONSTEXPR, BOOST_CONSTEXPR_OR_CONST and BOOST_NOEXCEPT
 
 // Control whether depreciated GCD and LCM functions are included (default: yes)
 #ifndef BOOST_CONTROL_RATIONAL_HAS_GCD
@@ -674,5 +677,90 @@
 
 } // namespace boost
 
+namespace std {
+
+template<typename IntType>
+struct numeric_limits< ::boost::rational<IntType> >
+{
+    static BOOST_CONSTEXPR_OR_CONST bool is_specialized = true;
+    static BOOST_CONSTEXPR_OR_CONST bool is_signed = ::std::numeric_limits<IntType>::is_signed;
+    static BOOST_CONSTEXPR_OR_CONST bool is_integer = false;
+    static BOOST_CONSTEXPR_OR_CONST bool is_exact = true;
+    
+    static BOOST_CONSTEXPR_OR_CONST bool has_infinity = false;
+    static BOOST_CONSTEXPR_OR_CONST bool has_quiet_NaN = false;
+    static BOOST_CONSTEXPR_OR_CONST bool has_signaling_NaN = false;
+
+    static BOOST_CONSTEXPR_OR_CONST std::float_denorm_style has_denorm = std::denorm_absent;
+    static BOOST_CONSTEXPR_OR_CONST bool has_denorm_loss = false;
+    static BOOST_CONSTEXPR_OR_CONST float_round_style round_style = round_toward_zero;
+    static BOOST_CONSTEXPR_OR_CONST bool is_iec559 = false;
+    static BOOST_CONSTEXPR_OR_CONST bool is_bounded = true;
+    static BOOST_CONSTEXPR_OR_CONST bool is_modulo = false;
+    
+    static BOOST_CONSTEXPR_OR_CONST int digits = ::std::numeric_limits<IntType>::digits;
+    static BOOST_CONSTEXPR_OR_CONST int digits10 = ::std::numeric_limits<IntType>::digits10;
+    // Add #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS ?
+    static BOOST_CONSTEXPR_OR_CONST int max_digits10 = 0;
+    static BOOST_CONSTEXPR_OR_CONST int radix = ::std::numeric_limits<IntType>::radix;
+    static BOOST_CONSTEXPR_OR_CONST int min_exponent = 0;
+    static BOOST_CONSTEXPR_OR_CONST int min_exponent10 = 0;
+    static BOOST_CONSTEXPR_OR_CONST int max_exponent = 0;
+    static BOOST_CONSTEXPR_OR_CONST int max_exponent10 = 0;
+
+    static BOOST_CONSTEXPR_OR_CONST bool traps = true;
+    static BOOST_CONSTEXPR_OR_CONST bool tinyness_before = false;
+
+    static BOOST_CONSTEXPR ::boost::rational<IntType> (min)() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(
+            1,
+            (::std::numeric_limits<IntType>::max)());
+    }
+    // Add #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS ?
+    static BOOST_CONSTEXPR ::boost::rational<IntType> lowest() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(
+            (::std::numeric_limits<IntType>::min)(), // or -(::std::numeric_limits<IntType>::max)() ?
+            (::std::numeric_limits<IntType>::max)());
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> (max)() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(
+            (::std::numeric_limits<IntType>::max)(),
+            1);
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> epsilon() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(
+            1,
+            (::std::numeric_limits<IntType>::max)());
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> denorm_min() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(
+            1,
+            (::std::numeric_limits<IntType>::max)());
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> round_error() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(1, 1);
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> infinity() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(0, 1);
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> quiet_NaN() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(0, 1);
+    }
+    static BOOST_CONSTEXPR ::boost::rational<IntType> signaling_NaN() BOOST_NOEXCEPT
+    {
+        return ::boost::rational<IntType>(0, 1);
+    }
+};
+
+} // namespace std
+
 #endif  // BOOST_RATIONAL_HPP