Chip 2011 November/CHIP_2011_11.iso/Programy/Narzedzia/Calibre/calibre-0.8.18.msi/file_262/numbers.pyo

Python Compiled Bytecode | 2011-09-09 | 8.4 KB | 307 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.7)

from __future__ import division
from abc import ABCMeta, abstractmethod, abstractproperty
__all__ = [
    'Number',
    'Complex',
    'Real',
    'Rational',
    'Integral']

class Number(object):
    __metaclass__ = ABCMeta
    __slots__ = ()
    __hash__ = None


class Complex(Number):
    __slots__ = ()

    def __complex__(self):
        pass

    __complex__ = abstractmethod(__complex__)

    def __nonzero__(self):
        return self != 0


    def real(self):
        raise NotImplementedError

    real = abstractproperty(real)

    def imag(self):
        raise NotImplementedError

    imag = abstractproperty(imag)

    def __add__(self, other):
        raise NotImplementedError

    __add__ = abstractmethod(__add__)

    def __radd__(self, other):
        raise NotImplementedError

    __radd__ = abstractmethod(__radd__)

    def __neg__(self):
        raise NotImplementedError

    __neg__ = abstractmethod(__neg__)

    def __pos__(self):
        raise NotImplementedError

    __pos__ = abstractmethod(__pos__)

    def __sub__(self, other):
        return self + -other


    def __rsub__(self, other):
        return -self + other


    def __mul__(self, other):
        raise NotImplementedError

    __mul__ = abstractmethod(__mul__)

    def __rmul__(self, other):
        raise NotImplementedError

    __rmul__ = abstractmethod(__rmul__)

    def __div__(self, other):
        raise NotImplementedError

    __div__ = abstractmethod(__div__)

    def __rdiv__(self, other):
        raise NotImplementedError

    __rdiv__ = abstractmethod(__rdiv__)

    def __truediv__(self, other):
        raise NotImplementedError

    __truediv__ = abstractmethod(__truediv__)

    def __rtruediv__(self, other):
        raise NotImplementedError

    __rtruediv__ = abstractmethod(__rtruediv__)

    def __pow__(self, exponent):
        raise NotImplementedError

    __pow__ = abstractmethod(__pow__)

    def __rpow__(self, base):
        raise NotImplementedError

    __rpow__ = abstractmethod(__rpow__)

    def __abs__(self):
        raise NotImplementedError

    __abs__ = abstractmethod(__abs__)

    def conjugate(self):
        raise NotImplementedError

    conjugate = abstractmethod(conjugate)

    def __eq__(self, other):
        raise NotImplementedError

    __eq__ = abstractmethod(__eq__)

    def __ne__(self, other):
        return not (self == other)


Complex.register(complex)

class Real(Complex):
    __slots__ = ()

    def __float__(self):
        raise NotImplementedError

    __float__ = abstractmethod(__float__)

    def __trunc__(self):
        raise NotImplementedError

    __trunc__ = abstractmethod(__trunc__)

    def __divmod__(self, other):
        return (self // other, self % other)


    def __rdivmod__(self, other):
        return (other // self, other % self)


    def __floordiv__(self, other):
        raise NotImplementedError

    __floordiv__ = abstractmethod(__floordiv__)

    def __rfloordiv__(self, other):
        raise NotImplementedError

    __rfloordiv__ = abstractmethod(__rfloordiv__)

    def __mod__(self, other):
        raise NotImplementedError

    __mod__ = abstractmethod(__mod__)

    def __rmod__(self, other):
        raise NotImplementedError

    __rmod__ = abstractmethod(__rmod__)

    def __lt__(self, other):
        raise NotImplementedError

    __lt__ = abstractmethod(__lt__)

    def __le__(self, other):
        raise NotImplementedError

    __le__ = abstractmethod(__le__)

    def __complex__(self):
        return complex(float(self))


    def real(self):
        return +self

    real = property(real)

    def imag(self):
        return 0

    imag = property(imag)

    def conjugate(self):
        return +self


Real.register(float)

class Rational(Real):
    __slots__ = ()

    def numerator(self):
        raise NotImplementedError

    numerator = abstractproperty(numerator)

    def denominator(self):
        raise NotImplementedError

    denominator = abstractproperty(denominator)

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



class Integral(Rational):
    __slots__ = ()

    def __long__(self):
        raise NotImplementedError

    __long__ = abstractmethod(__long__)

    def __index__(self):
        return long(self)


    def __pow__(self, exponent, modulus = None):
        raise NotImplementedError

    __pow__ = abstractmethod(__pow__)

    def __lshift__(self, other):
        raise NotImplementedError

    __lshift__ = abstractmethod(__lshift__)

    def __rlshift__(self, other):
        raise NotImplementedError

    __rlshift__ = abstractmethod(__rlshift__)

    def __rshift__(self, other):
        raise NotImplementedError

    __rshift__ = abstractmethod(__rshift__)

    def __rrshift__(self, other):
        raise NotImplementedError

    __rrshift__ = abstractmethod(__rrshift__)

    def __and__(self, other):
        raise NotImplementedError

    __and__ = abstractmethod(__and__)

    def __rand__(self, other):
        raise NotImplementedError

    __rand__ = abstractmethod(__rand__)

    def __xor__(self, other):
        raise NotImplementedError

    __xor__ = abstractmethod(__xor__)

    def __rxor__(self, other):
        raise NotImplementedError

    __rxor__ = abstractmethod(__rxor__)

    def __or__(self, other):
        raise NotImplementedError

    __or__ = abstractmethod(__or__)

    def __ror__(self, other):
        raise NotImplementedError

    __ror__ = abstractmethod(__ror__)

    def __invert__(self):
        raise NotImplementedError

    __invert__ = abstractmethod(__invert__)

    def __float__(self):
        return float(long(self))


    def numerator(self):
        return +self

    numerator = property(numerator)

    def denominator(self):
        return 1

    denominator = property(denominator)

Integral.register(int)
Integral.register(long)