Closed as not planned
Description
Feature or enhancement
Proposal:
Currently, most methods of the Fraction class subclasses return an instance of the Fraction class. That happens for arithmetic methods as well:
>>> from fractions import Fraction >>> class MyFraction(Fraction): ... pass ... a = MyFraction(1, 2) ... b = MyFraction(2, 3) ... >>> a+b Fraction(7, 6)I would guess, it was intentional.
On another hand, this makes subclassing of the Fraction - less useful. For example, what if we want to use something other than builtin int's for components of a fraction? Currently, it's possible, but... not quite:
>>> from gmpy2 import mpz >>> from fractions import Fraction >>> class mpq(Fraction): ... def __new__(cls, numerator=0, denominator=None): ... self = super(mpq, cls).__new__(cls, numerator, denominator) ... self._numerator = mpz(numerator) ... self._denominator = mpz(denominator) ... return self ... >>> a, b = mpq(1, 2), mpq(3, 4) >>> c = a + b >>> c._numerator # subclass instances use fast integer arithmetic mpz(5) >>> c._denominator mpz(4) >>> c # but it's still an instance of the Fraction! Fraction(5, 4)Attached patch fixes this.
To better support such subclasses, I think we could also add Fraction.gcd class attribute to override the math.gcd().
Of course, this is a compatibility break (patch breaks our CI tests). Though, looking on the GitHub search for subclasses of Fraction, I don't think this will really break some people code.
A quick patch
diff --git a/Lib/fractions.py b/Lib/fractions.py index cb05ae7c20..d81be2f90e 100644 --- a/Lib/fractions.py +++ b/Lib/fractions.py @@ -411,8 +411,9 @@ def limit_denominator(self, max_denominator=1000000): if max_denominator < 1: raise ValueError("max_denominator should be at least 1") + cls = self.__class__ if self._denominator <= max_denominator: - return Fraction(self) + return cls(self) p0, q0, p1, q1 = 0, 1, 1, 0 n, d = self._numerator, self._denominator @@ -430,9 +431,9 @@ def limit_denominator(self, max_denominator=1000000): # the distance from p1/q1 to self is d/(q1*self._denominator). So we # need to compare 2*(q0+k*q1) with self._denominator/d. if 2*d*(q0+k*q1) <= self._denominator: - return Fraction._from_coprime_ints(p1, q1) + return cls._from_coprime_ints(p1, q1) else: - return Fraction._from_coprime_ints(p0+k*p1, q0+k*q1) + return cls._from_coprime_ints(p0+k*p1, q0+k*q1) @property def numerator(a): @@ -782,38 +783,41 @@ def reverse(b, a): def _add(a, b): """a + b""" + cls = a.__class__ na, da = a._numerator, a._denominator nb, db = b._numerator, b._denominator g = math.gcd(da, db) if g == 1: - return Fraction._from_coprime_ints(na * db + da * nb, da * db) + return cls._from_coprime_ints(na * db + da * nb, da * db) s = da // g t = na * (db // g) + nb * s g2 = math.gcd(t, g) if g2 == 1: - return Fraction._from_coprime_ints(t, s * db) - return Fraction._from_coprime_ints(t // g2, s * (db // g2)) + return cls._from_coprime_ints(t, s * db) + return cls._from_coprime_ints(t // g2, s * (db // g2)) __add__, __radd__ = _operator_fallbacks(_add, operator.add) def _sub(a, b): """a - b""" + cls = a.__class__ na, da = a._numerator, a._denominator nb, db = b._numerator, b._denominator g = math.gcd(da, db) if g == 1: - return Fraction._from_coprime_ints(na * db - da * nb, da * db) + return cls._from_coprime_ints(na * db - da * nb, da * db) s = da // g t = na * (db // g) - nb * s g2 = math.gcd(t, g) if g2 == 1: - return Fraction._from_coprime_ints(t, s * db) - return Fraction._from_coprime_ints(t // g2, s * (db // g2)) + return cls._from_coprime_ints(t, s * db) + return cls._from_coprime_ints(t // g2, s * (db // g2)) __sub__, __rsub__ = _operator_fallbacks(_sub, operator.sub) def _mul(a, b): """a * b""" + cls = a.__class__ na, da = a._numerator, a._denominator nb, db = b._numerator, b._denominator g1 = math.gcd(na, db) @@ -824,13 +828,14 @@ def _mul(a, b): if g2 > 1: nb //= g2 da //= g2 - return Fraction._from_coprime_ints(na * nb, db * da) + return cls._from_coprime_ints(na * nb, db * da) __mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul) def _div(a, b): """a / b""" # Same as _mul(), with inversed b. + cls = a.__class__ nb, db = b._numerator, b._denominator if nb == 0: raise ZeroDivisionError('Fraction(%s, 0)' % db) @@ -846,7 +851,7 @@ def _div(a, b): n, d = na * db, nb * da if d < 0: n, d = -n, -d - return Fraction._from_coprime_ints(n, d) + return cls._from_coprime_ints(n, d) __truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv) @@ -858,6 +863,7 @@ def _floordiv(a, b): def _divmod(a, b): """(a // b, a % b)""" + cls = a.__class__ da, db = a.denominator, b.denominator div, n_mod = divmod(a.numerator * db, da * b.numerator) return div, Fraction(n_mod, da * db) @@ -866,8 +872,9 @@ def _divmod(a, b): def _mod(a, b): """a % b""" + cls = a.__class__ da, db = a.denominator, b.denominator - return Fraction((a.numerator * db) % (b.numerator * da), da * db) + return cls((a.numerator * db) % (b.numerator * da), da * db) __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod, False) @@ -881,21 +888,22 @@ def __pow__(a, b, modulo=None): """ if modulo is not None: return NotImplemented + cls = a.__class__ if isinstance(b, numbers.Rational): if b.denominator == 1: power = b.numerator if power >= 0: - return Fraction._from_coprime_ints(a._numerator ** power, - a._denominator ** power) + return cls._from_coprime_ints(a._numerator ** power, + a._denominator ** power) elif a._numerator > 0: - return Fraction._from_coprime_ints(a._denominator ** -power, - a._numerator ** -power) + return cls._from_coprime_ints(a._denominator ** -power, + a._numerator ** -power) elif a._numerator == 0: raise ZeroDivisionError('Fraction(%s, 0)' % a._denominator ** -power) else: - return Fraction._from_coprime_ints((-a._denominator) ** -power, - (-a._numerator) ** -power) + return cls._from_coprime_ints((-a._denominator) ** -power, + (-a._numerator) ** -power) else: # A fractional power will generally produce an # irrational number. @@ -923,15 +931,18 @@ def __rpow__(b, a, modulo=None): def __pos__(a): """+a: Coerces a subclass instance to Fraction""" - return Fraction._from_coprime_ints(a._numerator, a._denominator) + cls = a.__class__ + return cls._from_coprime_ints(a._numerator, a._denominator) def __neg__(a): """-a""" - return Fraction._from_coprime_ints(-a._numerator, a._denominator) + cls = a.__class__ + return cls._from_coprime_ints(-a._numerator, a._denominator) def __abs__(a): """abs(a)""" - return Fraction._from_coprime_ints(abs(a._numerator), a._denominator) + cls = a.__class__ + return cls._from_coprime_ints(abs(a._numerator), a._denominator) def __int__(a, _index=operator.index): """int(a)""" @@ -977,10 +988,11 @@ def __round__(self, ndigits=None): # See _operator_fallbacks.forward to check that the results of # these operations will always be Fraction and therefore have # round(). + cls = self.__class__ if ndigits > 0: - return Fraction(round(self * shift), shift) + return cls(round(self * shift), shift) else: - return Fraction(round(self / shift) * shift) + return cls(round(self / shift) * shift) def __hash__(self): """hash(self)""" diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py index d1d2739856..0e57478f1d 100644 --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -851,7 +851,7 @@ def testMixedMultiplication(self): self.assertTypedEquals(0.1 + 0j, (1.0 + 0j) * F(1, 10)) self.assertTypedEquals(F(3, 2) * DummyFraction(5, 3), F(5, 2)) - self.assertTypedEquals(DummyFraction(5, 3) * F(3, 2), F(5, 2)) + self.assertTypedEquals(DummyFraction(5, 3) * F(3, 2), DummyFraction(5, 2)) self.assertTypedEquals(F(3, 2) * Rat(5, 3), Rat(15, 6)) self.assertTypedEquals(Rat(5, 3) * F(3, 2), F(5, 2)) @@ -881,7 +881,7 @@ def testMixedDivision(self): self.assertTypedEquals(10.0 + 0j, (1.0 + 0j) / F(1, 10)) self.assertTypedEquals(F(3, 2) / DummyFraction(3, 5), F(5, 2)) - self.assertTypedEquals(DummyFraction(5, 3) / F(2, 3), F(5, 2)) + self.assertTypedEquals(DummyFraction(5, 3) / F(2, 3), DummyFraction(5, 2)) self.assertTypedEquals(F(3, 2) / Rat(3, 5), Rat(15, 6)) self.assertTypedEquals(Rat(5, 3) / F(2, 3), F(5, 2)) @@ -927,7 +927,7 @@ def testMixedIntegerDivision(self): self.assertTypedTupleEquals(divmod(-0.1, float('-inf')), divmod(F(-1, 10), float('-inf'))) self.assertTypedEquals(F(3, 2) % DummyFraction(3, 5), F(3, 10)) - self.assertTypedEquals(DummyFraction(5, 3) % F(2, 3), F(1, 3)) + self.assertTypedEquals(DummyFraction(5, 3) % F(2, 3), DummyFraction(1, 3)) self.assertTypedEquals(F(3, 2) % Rat(3, 5), Rat(3, 6)) self.assertTypedEquals(Rat(5, 3) % F(2, 3), F(1, 3)) Has this already been discussed elsewhere?
No response given
Links to previous discussion of this feature:
No response