Index: boost/rational.hpp
===================================================================
--- boost/rational.hpp	(revision 66258)
+++ boost/rational.hpp	(working copy)
@@ -56,6 +56,7 @@
 
 #include <iostream>              // for std::istream and std::ostream
 #include <ios>                   // for std::noskipws
+#include <math.h>                // for floor
 #include <stdexcept>             // for std::domain_error
 #include <string>                // for std::string implicit constructor
 #include <boost/operators.hpp>   // for boost::addable etc
@@ -105,23 +106,10 @@
 
 template <typename IntType>
 class rational :
-    less_than_comparable < rational<IntType>,
-    equality_comparable < rational<IntType>,
-    less_than_comparable2 < rational<IntType>, IntType,
-    equality_comparable2 < rational<IntType>, IntType,
-    addable < rational<IntType>,
-    subtractable < rational<IntType>,
-    multipliable < rational<IntType>,
-    dividable < rational<IntType>,
-    addable2 < rational<IntType>, IntType,
-    subtractable2 < rational<IntType>, IntType,
-    subtractable2_left < rational<IntType>, IntType,
-    multipliable2 < rational<IntType>, IntType,
-    dividable2 < rational<IntType>, IntType,
-    dividable2_left < rational<IntType>, IntType,
-    incrementable < rational<IntType>,
-    decrementable < rational<IntType>
-    > > > > > > > > > > > > > > > >
+    ordered_euclidean_ring_operators < rational<IntType>,
+    ordered_euclidean_ring_operators2 < rational<IntType>, IntType,
+    unit_steppable < rational<IntType>
+    > > >
 {
     // Class-wide pre-conditions
     BOOST_STATIC_ASSERT( ::std::numeric_limits<IntType>::is_specialized );
@@ -155,11 +143,13 @@
     rational& operator-= (const rational& r);
     rational& operator*= (const rational& r);
     rational& operator/= (const rational& r);
+    rational& operator%= (const rational& r);
 
     rational& operator+= (param_type i);
     rational& operator-= (param_type i);
     rational& operator*= (param_type i);
     rational& operator/= (param_type i);
+    rational& operator%= (param_type i);
 
     // Increment and decrement
     const rational& operator++();
@@ -215,6 +205,14 @@
     return *this;
 }
 
+// Type conversion
+template <typename T, typename IntType>
+inline T rational_cast(
+    const rational<IntType>& src BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
+{
+    return static_cast<T>(src.numerator())/static_cast<T>(src.denominator());
+}
+
 // Unary plus and minus
 template <typename IntType>
 inline rational<IntType> operator+ (const rational<IntType>& r)
@@ -327,6 +325,12 @@
     return *this;
 }
 
+template <typename IntType>
+rational<IntType>& rational<IntType>::operator%= (const rational<IntType>& r)
+{
+    return *this -= r * floor(rational_cast<double>(*this / r));
+}
+
 // Mixed-mode operators
 template <typename IntType>
 inline rational<IntType>&
@@ -356,6 +360,13 @@
     return operator/= (rational<IntType>(i));
 }
 
+template <typename IntType>
+inline rational<IntType>&
+rational<IntType>::operator%= (param_type i)
+{
+    return operator%= (rational<IntType>(i));
+}
+
 // Increment and decrement
 template <typename IntType>
 inline const rational<IntType>& rational<IntType>::operator++()
@@ -583,14 +594,6 @@
     return os;
 }
 
-// Type conversion
-template <typename T, typename IntType>
-inline T rational_cast(
-    const rational<IntType>& src BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
-{
-    return static_cast<T>(src.numerator())/static_cast<T>(src.denominator());
-}
-
 // Do not use any abs() defined on IntType - it isn't worth it, given the
 // difficulties involved (Koenig lookup required, there may not *be* an abs()
 // defined, etc etc).