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.
 """
 @abstractmethod
 def__complex__(self):
"""Return a builtin complex instance."""
 def__bool__(self):
"""True if self != 0."""
 return self != 0
 @abstractproperty
 defreal(self):
"""Retrieve the real component of this number.
 This should subclass Real.
 """
 raise NotImplementedError
 @abstractproperty
 defimag(self):
"""Retrieve the imaginary component of this number.
 This should subclass Real.
 """
 raise NotImplementedError
 @abstractmethod
 def__add__(self, other):
 raise NotImplementedError
 @abstractmethod
 def__radd__(self, other):
 raise NotImplementedError
 @abstractmethod
 def__neg__(self):
 raise NotImplementedError
 def__pos__(self):
"""Coerces self to whatever class defines the method."""
 raise NotImplementedError
 def__sub__(self, other):
 return self + -other
 def__rsub__(self, other):
 return -self + other
 @abstractmethod
 def__mul__(self, other):
 raise NotImplementedError
 @abstractmethod
 def__rmul__(self, other):
 raise NotImplementedError
 @abstractmethod
 def__div__(self, other):
"""a/b; should promote to float or complex when necessary."""
 raise NotImplementedError
 @abstractmethod
 def__rdiv__(self, other):
 raise NotImplementedError
 @abstractmethod
 def__pow__(self, exponent):
"""a**b; should promote to float or complex when necessary."""
 raise NotImplementedError
 @abstractmethod
 def__rpow__(self, base):
 raise NotImplementedError
 @abstractmethod
 def__abs__(self):
"""Returns the Real distance from 0."""
 raise NotImplementedError
 @abstractmethod
 defconjugate(self):
"""(x+y*i).conjugate() returns (x-y*i)."""
 raise NotImplementedError
 @abstractmethod
 def__eq__(self, other):
 raise NotImplementedError
 # __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?
 @abstractmethod
 def__float__(self):
"""Any Real can be converted to a native float object."""
 raise NotImplementedError
 @abstractmethod
 def__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".
 """
 raise NotImplementedError
 @abstractmethod
 def__floor__(self):
"""Finds the greatest Integral <= self."""
 raise NotImplementedError
 @abstractmethod
 def__ceil__(self):
"""Finds the least Integral >= self."""
 raise NotImplementedError
 @abstractmethod
 def__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.
 """
 raise NotImplementedError
 def__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)
 @abstractmethod
 def__floordiv__(self, other):
"""The floor() of self/other. Integral."""
 raise NotImplementedError
 @abstractmethod
 def__rfloordiv__(self, other):
"""The floor() of other/self."""
 raise NotImplementedError
 @abstractmethod
 def__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.
 """
 raise NotImplementedError
 @abstractmethod
 def__rmod__(self, other):
"""other % self"""
 raise NotImplementedError
 @abstractmethod
 def__lt__(self, other):
"""< on Reals defines a total ordering, except perhaps for NaN."""
 raise NotImplementedError
 @abstractmethod
 def__le__(self, other):
 raise NotImplementedError
 # __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):
 return complex(float(self))
 @property
 defreal(self):
 return +self
 @property
 defimag(self):
 return 0
 defconjugate(self):
"""Conjugate is a no-op for Reals."""
 return +self

classRational(Real, Exact):
""".numerator and .denominator should be in lowest terms."""
 @abstractproperty
 defnumerator(self):
 raise NotImplementedError
 @abstractproperty
 defdenominator(self):
 raise NotImplementedError
 # Concrete implementation of Real's conversion to float.
 # (This invokes Integer.__div__().)
 def__float__(self):
 return self.numerator / self.denominator

classIntegral(Rational):
"""Integral adds a conversion to int and the bit-string operations."""
 @abstractmethod
 def__int__(self):
 raise NotImplementedError
 def__index__(self):
"""__index__() exists because float has __int__()."""
 return int(self)
 def__lshift__(self, other):
 return int(self) << int(other)
 def__rlshift__(self, other):
 return int(other) << int(self)
 def__rshift__(self, other):
 return int(self) >> int(other)
 def__rrshift__(self, other):
 return int(other) >> int(self)
 def__and__(self, other):
 return int(self) & int(other)
 def__rand__(self, other):
 return int(other) & int(self)
 def__xor__(self, other):
 return int(self) ^ int(other)
 def__rxor__(self, other):
 return int(other) ^ int(self)
 def__or__(self, other):
 return int(self) | int(other)
 def__ror__(self, other):
 return int(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))"""
 return float(int(self))
 @property
 defnumerator(self):
"""Integers are their own numerators."""
 return +self
 @property
 defdenominator(self):
"""Integers have a denominator of 1."""
 return 1

def__hash__(self):
 return hash(complex(self))