bpo-35588: Implement mod and divmod operations for Fraction type by spelling out the numerator/denominator calculation, instead of instantiating and normalising Fractions along the way. This speeds up '%' and divmod() by 2-3x.

Author: scoder

Lib/fractions.py

@@ -35,6 +35,17 @@ def _gcd(a, b):
         a, b = b, a%b
     return a
 
+
+def _flat_divmod(na, da, nb, db):
+    """(a // b, a % b)"""
+    # div = a // b
+    n_div, d_div = na * db, da * nb
+    div = n_div // d_div
+    # mod = a - b * div == (na*db - da*nb * div) / (da*db)
+    n_mod, d_mod = n_div - d_div * div, da*db
+    return div, n_mod, d_mod
+
+
 # Constants related to the hash implementation;  hash(x) is based
 # on the reduction of x modulo the prime _PyHASH_MODULUS.
 _PyHASH_MODULUS = sys.hash_info.modulus
@@ -433,10 +444,19 @@ def _floordiv(a, b):
 
     __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv)
 
+    def _divmod(a, b):
+        """(a // b, a % b)"""
+        div, n_mod, d_mod = _flat_divmod(
+            a.numerator, a.denominator, b.numerator, b.denominator)
+        return Fraction(div), Fraction(n_mod, d_mod)
+
+    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod)
+
     def _mod(a, b):
         """a % b"""
-        div = a // b
-        return a - b * div
+        _, n_mod, d_mod = _flat_divmod(
+            a.numerator, a.denominator, b.numerator, b.denominator)
+        return Fraction(n_mod, d_mod)
 
     __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod)
 

Lib/test/test_fractions.py

@@ -117,6 +117,12 @@ def assertTypedEquals(self, expected, actual):
         self.assertEqual(type(expected), type(actual))
         self.assertEqual(expected, actual)
 
+    def assertTypedTupleEquals(self, expected, actual):
+        """Asserts that both the types and values in the tuples are the same."""
+        self.assertIsInstance(actual, tuple)
+        self.assertEqual(list(map(type, expected)), list(map(type, actual)))
+        self.assertEqual(expected, actual)
+
     def assertRaisesMessage(self, exc_type, message,
                             callable, *args, **kwargs):
         """Asserts that callable(*args, **kwargs) raises exc_type(message)."""
@@ -349,7 +355,10 @@ def testArithmetic(self):
         self.assertEqual(F(1, 4), F(1, 10) / F(2, 5))
         self.assertTypedEquals(2, F(9, 10) // F(2, 5))
         self.assertTypedEquals(10**23, F(10**23, 1) // F(1))
+        self.assertEqual(F(5, 6), F(7, 3) % F(3, 2))
         self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2))
+        self.assertEqual((F(1), F(5, 6)), divmod(F(7, 3), F(3, 2)))
+        self.assertEqual((F(-2), F(2, 3)), divmod(F(-7, 3), F(3, 2)))
         self.assertEqual(F(8, 27), F(2, 3) ** F(3))
         self.assertEqual(F(27, 8), F(2, 3) ** F(-3))
         self.assertTypedEquals(2.0, F(4) ** F(1, 2))
@@ -415,7 +424,14 @@ def testMixedArithmetic(self):
         self.assertTypedEquals(float('inf'), F(-1, 10) % float('inf'))
         self.assertTypedEquals(-0.1, F(-1, 10) % float('-inf'))
 
-        # No need for divmod since we don't override it.
+        self.assertTypedTupleEquals((F(0), F(1, 10)), divmod(F(1, 10), 1))
+        self.assertTypedTupleEquals(divmod(0.1, 1.0), divmod(F(1, 10), 1.0))
+        self.assertTypedTupleEquals((F(10, 1), F(0)), divmod(1, F(1, 10)))
+        self.assertTypedTupleEquals(divmod(1.0, 0.1), divmod(1.0, F(1, 10)))
+        self.assertTypedTupleEquals(divmod(0.1, float('inf')), divmod(F(1, 10), float('inf')))
+        self.assertTypedTupleEquals(divmod(0.1, float('-inf')), divmod(F(1, 10), float('-inf')))
+        self.assertTypedTupleEquals(divmod(-0.1, float('inf')), divmod(F(-1, 10), float('inf')))
+        self.assertTypedTupleEquals(divmod(-0.1, float('-inf')), divmod(F(-1, 10), float('-inf')))
 
         # ** has more interesting conversion rules.
         self.assertTypedEquals(F(100, 1), F(1, 10) ** -2)

Misc/NEWS.d/next/Library/2018-12-26-10-55-59.bpo-35588.PSR6Ez.rst

@@ -0,0 +1,2 @@
+Mod and divmod operations on :class:`fractions.Fraction` types are 2-3x faster.
+Patch by Stefan Behnel.