classNumber(metaclass=ABCMeta):pass

classComplex(Number):"""Complex defines the operations that work on the builtin complex type.    In short, those are: conversion to complex, bool(), .real, .imag,    +, -, *, /, **, abs(), .conjugate(), ==, and !=.    If it is given heterogeneous arguments, and doesn't have special    knowledge about them, it should fall back to the builtin complex    type as described below.    """@abstractmethoddef__complex__(self):"""Return a builtin complex instance."""def__bool__(self):"""True if self != 0."""returnself!=0@abstractpropertydefreal(self):"""Retrieve the real component of this number.        This should subclass Real.        """raiseNotImplementedError@abstractpropertydefimag(self):"""Retrieve the imaginary component of this number.        This should subclass Real.        """raiseNotImplementedError@abstractmethoddef__add__(self,other):raiseNotImplementedError@abstractmethoddef__radd__(self,other):raiseNotImplementedError@abstractmethoddef__neg__(self):raiseNotImplementedErrordef__pos__(self):"""Coerces self to whatever class defines the method."""raiseNotImplementedErrordef__sub__(self,other):returnself+-otherdef__rsub__(self,other):return-self+other@abstractmethoddef__mul__(self,other):raiseNotImplementedError@abstractmethoddef__rmul__(self,other):raiseNotImplementedError@abstractmethoddef__div__(self,other):"""a/b; should promote to float or complex when necessary."""raiseNotImplementedError@abstractmethoddef__rdiv__(self,other):raiseNotImplementedError@abstractmethoddef__pow__(self,exponent):"""a**b; should promote to float or complex when necessary."""raiseNotImplementedError@abstractmethoddef__rpow__(self,base):raiseNotImplementedError@abstractmethoddef__abs__(self):"""Returns the Real distance from 0."""raiseNotImplementedError@abstractmethoddefconjugate(self):"""(x+y*i).conjugate() returns (x-y*i)."""raiseNotImplementedError@abstractmethoddef__eq__(self,other):raiseNotImplementedError# __ne__ is inherited from object and negates whatever __eq__ does.

classReal(Complex):"""To Complex, Real adds the operations that work on real numbers.    In short, those are: conversion to float, trunc(), math.floor(),    math.ceil(), round(), divmod(), //, %, <, <=, >, and >=.    Real also provides defaults for some of the derived operations.    """# XXX What to do about the __int__ implementation that's# currently present on float?  Get rid of it?@abstractmethoddef__float__(self):"""Any Real can be converted to a native float object."""raiseNotImplementedError@abstractmethoddef__trunc__(self):"""Truncates self to an Integral.        Returns an Integral i such that:          * i>=0 iff self>0;          * abs(i) <= abs(self);          * for any Integral j satisfying the first two conditions,            abs(i) >= abs(j) [i.e. i has "maximal" abs among those].        i.e. "truncate towards 0".        """raiseNotImplementedError@abstractmethoddef__floor__(self):"""Finds the greatest Integral <= self."""raiseNotImplementedError@abstractmethoddef__ceil__(self):"""Finds the least Integral >= self."""raiseNotImplementedError@abstractmethoddef__round__(self,ndigits:Integral=None):"""Rounds self to ndigits decimal places, defaulting to 0.        If ndigits is omitted or None, returns an Integral,        otherwise returns a Real, preferably of the same type as        self. Types may choose which direction to round half. For        example, float rounds half toward even.        """raiseNotImplementedErrordef__divmod__(self,other):"""The pair (self // other, self % other).        Sometimes this can be computed faster than the pair of        operations.        """return(self//other,self%other)def__rdivmod__(self,other):"""The pair (self // other, self % other).        Sometimes this can be computed faster than the pair of        operations.        """return(other//self,other%self)@abstractmethoddef__floordiv__(self,other):"""The floor() of self/other. Integral."""raiseNotImplementedError@abstractmethoddef__rfloordiv__(self,other):"""The floor() of other/self."""raiseNotImplementedError@abstractmethoddef__mod__(self,other):"""self % other        See        https://mail.python.org/pipermail/python-3000/2006-May/001735.html        and consider using "self/other - trunc(self/other)"        instead if you're worried about round-off errors.        """raiseNotImplementedError@abstractmethoddef__rmod__(self,other):"""other % self"""raiseNotImplementedError@abstractmethoddef__lt__(self,other):"""< on Reals defines a total ordering, except perhaps for NaN."""raiseNotImplementedError@abstractmethoddef__le__(self,other):raiseNotImplementedError# __gt__ and __ge__ are automatically done by reversing the arguments.# (But __le__ is not computed as the opposite of __gt__!)# Concrete implementations of Complex abstract methods.# Subclasses may override these, but don't have to.def__complex__(self):returncomplex(float(self))@propertydefreal(self):return+self@propertydefimag(self):return0defconjugate(self):"""Conjugate is a no-op for Reals."""return+self

classRational(Real,Exact):""".numerator and .denominator should be in lowest terms."""@abstractpropertydefnumerator(self):raiseNotImplementedError@abstractpropertydefdenominator(self):raiseNotImplementedError# Concrete implementation of Real's conversion to float.# (This invokes Integer.__div__().)def__float__(self):returnself.numerator/self.denominator

classIntegral(Rational):"""Integral adds a conversion to int and the bit-string operations."""@abstractmethoddef__int__(self):raiseNotImplementedErrordef__index__(self):"""__index__() exists because float has __int__()."""returnint(self)def__lshift__(self,other):returnint(self)<<int(other)def__rlshift__(self,other):returnint(other)<<int(self)def__rshift__(self,other):returnint(self)>>int(other)def__rrshift__(self,other):returnint(other)>>int(self)def__and__(self,other):returnint(self)&int(other)def__rand__(self,other):returnint(other)&int(self)def__xor__(self,other):returnint(self)^int(other)def__rxor__(self,other):returnint(other)^int(self)def__or__(self,other):returnint(self)|int(other)def__ror__(self,other):returnint(other)|int(self)def__invert__(self):return~int(self)# Concrete implementations of Rational and Real abstract methods.def__float__(self):"""float(self) == float(int(self))"""returnfloat(int(self))@propertydefnumerator(self):"""Integers are their own numerators."""return+self@propertydefdenominator(self):"""Integers have a denominator of 1."""return1

def__hash__(self):returnhash(complex(self))