Index: boost/rational.hpp
===================================================================
--- boost/rational.hpp	(revision 73242)
+++ boost/rational.hpp	(working copy)
@@ -105,23 +105,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 +142,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++();
@@ -205,6 +194,14 @@
     void normalize();
 };
 
+// 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());
+}
+
 // Assign in place
 template <typename IntType>
 inline rational<IntType>& rational<IntType>::assign(param_type n, param_type d)
@@ -327,6 +324,12 @@
     return *this;
 }
 
+template <typename IntType>
+rational<IntType>& rational<IntType>::operator%= (const rational<IntType>& r)
+{
+    return *this -= r * rational_cast<IntType>(*this / r);
+}
+
 // Mixed-mode operators
 template <typename IntType>
 inline rational<IntType>&
@@ -356,6 +359,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,24 +593,13 @@
     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).
 template <typename IntType>
 inline rational<IntType> abs(const rational<IntType>& r)
 {
-    if (r.numerator() >= IntType(0))
-        return r;
-
-    return rational<IntType>(-r.numerator(), r.denominator());
+    return r.numerator() >= IntType(0)? r: -r;
 }
 
 } // namespace boost