[Python-3000] Updated and simplified PEP 3141: A Type Hierarchy for Numbers (original) (raw)

Thu May 17 02:31:50 CEST 2007

class Exact(metaclass=MetaABC): pass
class Inexact(metaclass=MetaABC): pass
class Number(metaclass=MetaABC): pass
class NotANumber(Number):
    """Implement IEEE 754 semantics."""
    def __lt__(self, other): return false
    def __eq__(self, other): return false
    ...
    def __add__(self, other): return self
    def __radd__(self, other): return self
    ...
class Complex(Hashable, Number):
    """A ``Complex`` should define the operations that work on the
    Python ``complex`` type. If it is given heterogenous
    arguments, it may fall back on this class's definition of the
    operations. These operators should never return a
    TypeError as long as both arguments are instances of Complex
    (or even just implement __complex__).
    """
    @abstractmethod
    def __complex__(self):
        """This operation gives the arithmetic operations a fallback.
        """
        return complex(self.real, self.imag)
    @property
    def real(self):
        return complex(self).real
    @property
    def imag(self):
        return complex(self).imag
    def __radd__(self, other):
        """Should this catch any type errors and return
        NotImplemented instead?"""
        return complex(other) + complex(self)
    def __rsub__(self, other):
        return complex(other) - complex(self)
    def __neg__(self):
        return -complex(self)
    def __rmul__(self, other):
        return complex(other) * complex(self)
    def __rdiv__(self, other):
        return complex(other) / complex(self)

    def __abs__(self):
        return abs(complex(self))

    def conjugate(self):
        return complex(self).conjugate()

    def __hash__(self):
        """Two "equal" values of different complex types should
        hash in the same way."""
    return hash(complex(self))
class Real(Complex, metaclass=TotallyOrderedABC):
    @abstractmethod
def __float__(self):
    """Any Real can be converted to a native float object."""
    raise NotImplementedError
    def __complex__(self):
        """Which gives us an easy way to define the conversion to
        complex."""
        return complex(float(self))
    @property
    def real(self): return self
    @property
    def imag(self): return 0

    def __radd__(self, other):
        if isinstance(other, Real):
            return float(other) + float(self)
        else:
            return super(Real, self).__radd__(other)
    def __rsub__(self, other):
        if isinstance(other, Real):
            return float(other) - float(self)
        else:
            return super(Real, self).__rsub__(other)
    def __neg__(self):
        return -float(self)
    def __rmul__(self, other):
        if isinstance(other, Real):
            return float(other) * float(self)
        else:
            return super(Real, self).__rmul__(other)
    def __rdiv__(self, other):
        if isinstance(other, Real):
            return float(other) / float(self)
        else:
            return super(Real, self).__rdiv__(other)
    def __rdivmod__(self, other):
        """Implementing divmod() for your type is sufficient to
        get floordiv and mod too.
        """
        if isinstance(other, Real):
            return divmod(float(other), float(self))
        else:
            return super(Real, self).__rdivmod__(other)
    def __rfloordiv__(self, other):
        return divmod(other, self)[0]
    def __rmod__(self, other):
        return divmod(other, self)[1]

def __trunc__(self):
        """Do we want properfraction, floor, ceiling, and round?"""
        return trunc(float(self))

    def __abs__(self):
        return abs(float(self))
    def __lt__(self, other):
        """The comparison operators in Python seem to be more
        strict about their input types than other functions. I'm
        guessing here that we want types to be incompatible even
        if they define a __float__ operation, unless they also
        declare themselves to be Real numbers.
        """
        if isinstance(other, Real):
            return float(self) < float(other)
        else:
            return NotImplemented

    def __le__(self, other):
        if isinstance(other, Real):
            return float(self) <= float(other)
        else:
            return NotImplemented

    def __eq__(self, other):
        if isinstance(other, Real):
            return float(self) == float(other)
        else:
            return NotImplemented
class Rational(Real, Exact):
    """rational.numerator and rational.denominator should be in
    lowest terms.
    """
    @abstractmethod
    @property
    def numerator(self):
        raise NotImplementedError
    @abstractmethod
    @property
    def denominator(self):
        raise NotImplementedError

    def __float__(self):
        return self.numerator / self.denominator


class Integer(Rational):
@abstractmethod
def __int__(self):
    raise NotImplementedError
def __float__(self):
    return float(int(self))
    @property
    def numerator(self): return self
    @property
    def denominator(self): return 1

def __ror__(self, other):
    return int(other) | int(self)
def __rxor__(self, other):
    return int(other) ^ int(self)
def __rand__(self, other):
    return int(other) & int(self)
def __rlshift__(self, other):
    return int(other) << int(self)
def __rrshift__(self, other):
    return int(other) >> int(self)
def __invert__(self):
    return ~int(self)

    def __radd__(self, other):
        """All of the Real methods need to be overridden here too
        in order to get a more exact type for their results.
        """
        if isinstance(other, Integer):
            return int(other) + int(self)
        else:
            return super(Integer, self).__radd__(other)
    ...

    def __hash__(self):
        """Surprisingly, hash() needs to be overridden too, since
        there are integers that float can't represent."""
        return hash(int(self))
class MyFoo(Complex): ...
MyFoo.register(Real)

[Python-3000] Updated and simplified PEP 3141: A Type Hierarchy for Numbers (original) (raw)

Abstract

Rationale

Specification

Exact vs. Inexact Classes

Numeric Classes

Adding More Numeric ABCs

Rejected Alternatives

References

Acknowledgements

Copyright