�
zfc@ s�dZd
dl
mZ
d
dlmZmZmZ
dddddgZdef
d	��YZ	de	f
d
��YZ
e
je�

de
f
d��YZ
e
je�

de
f
d��YZdef
d
��YZeje�

eje�

dS(s~Abstract Base Classes (ABCs) for numbers, according to PEP 3141.

TODO: Fill out more detailed documentation on the operators.i����(
tdivision(tABCMetatabstractmethodtabstractpropertytNumbertComplextRealtRationaltIntegralc
B s eZ
dZeZd
ZdZRS(s�All numbers inherit from this class.

    If you just want to check if an argument x is a number, without
    caring what kind, use isinstance(x, Number).
    (N(t__name__t
__module__t__doc__R
t
__metaclass__t	__slots__tNonet__hash__(((s/usr/lib64/python2.7/numbers.pyR
s

cB sF
eZ
dZdZed
��
Zd�Zed��
Zed��
Z	ed��
Z
ed��
Zed��
Zed��
Z
d	�Zd
�Zed��
Zed��
Zed
��
Zed��
Zed��
Zed��
Zed��
Zed��
Zed��
Zed��
Zed��
Zd�ZRS(sa
Complex defines the operations that work on the builtin complex type.

    In short, those are: a conversion to complex, .real, .imag, +, -,
    *, /, abs(), .conjugate, ==, and !=.

    If it is given heterogenous arguments, and doesn't have special
    knowledge about them, it should fall back to the builtin complex
    type as described below.
    c


C sd
S(s<Return a builtin complex instance. Called for complex(self).N((
tself((s/usr/lib64/python2.7/numbers.pyt__complex__/tc

C s
|d
kS(s)True if self != 0. Called for bool(self).i((
R((s/usr/lib64/python2.7/numbers.pyt__nonzero__4sc


C s
t�
d
S(sXRetrieve the real component of this number.

        This should subclass Real.
        N(
tNotImplementedError(
R((s/usr/lib64/python2.7/numbers.pytreal8sc


C s
t�
d
S(s]Retrieve the imaginary component of this number.

        This should subclass Real.
        N(
R(
R((s/usr/lib64/python2.7/numbers.pytimag@sc
C s
t�
d
S(sself + otherN(
R(Rtother((s/usr/lib64/python2.7/numbers.pyt__add__Hsc
C s
t�
d
S(sother + selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__radd__Msc


C s
t�
d
S(s-selfN(
R(
R((s/usr/lib64/python2.7/numbers.pyt__neg__Rsc


C s
t�
d
S(s+selfN(
R(
R((s/usr/lib64/python2.7/numbers.pyt__pos__WscC s	||
S(
sself - other((RR((s/usr/lib64/python2.7/numbers.pyt__sub__\scC s	||
S(
sother - self((RR((s/usr/lib64/python2.7/numbers.pyt__rsub__`sc
C s
t�
d
S(sself * otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__mul__dsc
C s
t�
d
S(sother * selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rmul__isc
C s
t�
d
S(sPself / other without __future__ division

        May promote to float.
        N(
R(RR((s/usr/lib64/python2.7/numbers.pyt__div__nsc
C s
t�
d
S(s(other / self without __future__ divisionN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rdiv__vsc
C s
t�
d
S(s`self / other with __future__ division.

        Should promote to float when necessary.
        N(
R(RR((s/usr/lib64/python2.7/numbers.pyt__truediv__{sc
C s
t�
d
S(s%other / self with __future__ divisionN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rtruediv__�sc
C s
t�
d
S(sBself**exponent; should promote to float or complex when necessary.N(
R(Rtexponent((s/usr/lib64/python2.7/numbers.pyt__pow__�sc
C s
t�
d
S(sbase ** selfN(
R(Rtbase((s/usr/lib64/python2.7/numbers.pyt__rpow__�sc


C s
t�
d
S(s7Returns the Real distance from 0. Called for abs(self).N(
R(
R((s/usr/lib64/python2.7/numbers.pyt__abs__�sc


C s
t�
d
S(s$(x+y*i).conjugate() returns (x-y*i).N(
R(
R((s/usr/lib64/python2.7/numbers.pyt	conjugate�sc
C s
t�
d
S(s
self == otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__eq__�scC s||
kS(
s
self != other((RR((s/usr/lib64/python2.7/numbers.pyt__ne__�s((R	R
RR
RRRRRRRRRRRRRRR R!R"R#R%R'R(R)R*R+(((s/usr/lib64/python2.7/numbers.pyR"s0				cB s�eZ
dZdZed
��
Zed��
Zd�Zd�Zed��
Z	ed��
Z
ed��
Zed��
Zed	��
Z
ed
��
Zd�Zed��
Zed
��
Zd�ZRS(s�To Complex, Real adds the operations that work on real numbers.

    In short, those are: a conversion to float, trunc(), divmod,
    %, <, <=, >, and >=.

    Real also provides defaults for the derived operations.
    c


C s
t�
d
S(sTAny Real can be converted to a native float object.

        Called for float(self).N(
R(
R((s/usr/lib64/python2.7/numbers.pyt	__float__�sc


C s
t�
d
S(sG
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".
        N(
R(
R((s/usr/lib64/python2.7/numbers.pyt	__trunc__�scC s||
||
fS(
s�divmod(self, other): The pair (self // other, self % other).

        Sometimes this can be computed faster than the pair of
        operations.
        ((RR((s/usr/lib64/python2.7/numbers.pyt
__divmod__�scC s|
||
|fS(
s�divmod(other, self): The pair (self // other, self % other).

        Sometimes this can be computed faster than the pair of
        operations.
        ((RR((s/usr/lib64/python2.7/numbers.pyt__rdivmod__�sc
C s
t�
d
S(s)self // other: The floor() of self/other.N(
R(RR((s/usr/lib64/python2.7/numbers.pyt__floordiv__�sc
C s
t�
d
S(s)other // self: The floor() of other/self.N(
R(RR((s/usr/lib64/python2.7/numbers.pyt
__rfloordiv__�sc
C s
t�
d
S(sself % otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__mod__�sc
C s
t�
d
S(sother % selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rmod__�sc
C s
t�
d
S(sRself < other

        < on Reals defines a total ordering, except perhaps for NaN.N(
R(RR((s/usr/lib64/python2.7/numbers.pyt__lt__�sc
C s
t�
d
S(s
self <= otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__le__�sc

C stt
|�
�
S(
s(complex(self) == complex(float(self), 0)(tcomplextfloat(
R((s/usr/lib64/python2.7/numbers.pyR�sc


C s|
S(
s&Real numbers are their real component.((
R((s/usr/lib64/python2.7/numbers.pyR�sc


C sd
S(s)Real numbers have no imaginary component.i((
R((s/usr/lib64/python2.7/numbers.pyR
sc


C s|
S(
sConjugate is a no-op for Reals.((
R((s/usr/lib64/python2.7/numbers.pyR)
s((R	R
RR
RR,R-R.R/R0R1R2R3R4R5RtpropertyRRR)(((s/usr/lib64/python2.7/numbers.pyR�s 
			cB s;eZ
dZdZed
��
Zed��
Zd�ZRS(s6.numerator and .denominator should be in lowest terms.c


C s
t�
dS(
N(
R(
R((s/usr/lib64/python2.7/numbers.pyt	numerator
sc


C s
t�
dS(
N(
R(
R((s/usr/lib64/python2.7/numbers.pytdenominator
sc

C s|j|j
S(
s
float(self) = self.numerator / self.denominator

        It's important that this conversion use the integer's "true"
        division rather than casting one side to float before dividing
        so that ratios of huge integers convert without overflowing.

        (R9R:(
R((s/usr/lib64/python2.7/numbers.pyR,
s((R	R
RR
RR9R:R,(((s/usr/lib64/python2.7/numbers.pyR
s

cB s

eZ
dZdZed
��
Zd�Zedd�
�
Zed��
Z	ed��
Z
ed��
Zed��
Zed��
Z
ed	��
Zed
��
Zed��
Zed��
Zed
��
Zed��
Zd�Zed��
Zed��
ZRS(sAIntegral adds a conversion to long and the bit-string operations.c


C s
t�
d
S(s
long(self)N(
R(
R((s/usr/lib64/python2.7/numbers.pyt__long__,
sc

C s
t|�
S(
s6Called whenever an index is needed, such as in slicing(
tlong(
R((s/usr/lib64/python2.7/numbers.pyt	__index__1
sc
C s
t�
d
S(s4
self ** exponent % modulus, but maybe faster.

        Accept the modulus argument if you want to support the
        3-argument version of pow(). Raise a TypeError if exponent < 0
        or any argument isn't Integral. Otherwise, just implement the
        2-argument version described in Complex.
        N(
R(RR$tmodulus((s/usr/lib64/python2.7/numbers.pyR%5
s	c
C s
t�
d
S(s
self << otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt
__lshift__@
sc
C s
t�
d
S(s
other << selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rlshift__E
sc
C s
t�
d
S(s
self >> otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt
__rshift__J
sc
C s
t�
d
S(s
other >> selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rrshift__O
sc
C s
t�
d
S(sself & otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__and__T
sc
C s
t�
d
S(sother & selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rand__Y
sc
C s
t�
d
S(sself ^ otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__xor__^
sc
C s
t�
d
S(sother ^ selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__rxor__c
sc
C s
t�
d
S(sself | otherN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__or__h
sc
C s
t�
d
S(sother | selfN(
R(RR((s/usr/lib64/python2.7/numbers.pyt__ror__m
sc


C s
t�
d
S(s~selfN(
R(
R((s/usr/lib64/python2.7/numbers.pyt
__invert__r
sc

C stt
|�
�
S(
s float(self) == float(long(self))(R7R<(
R((s/usr/lib64/python2.7/numbers.pyR,x
sc


C s|
S(
s"Integers are their own numerators.((
R((s/usr/lib64/python2.7/numbers.pyR9|
sc


C sd
S(s!Integers have a denominator of 1.i
((
R((s/usr/lib64/python2.7/numbers.pyR:�
s(N(R	R
RR
RR;R=RR%R?R@RARBRCRDRERFRGRHRIR,R8R9R:(((s/usr/lib64/python2.7/numbers.pyR'
s(
	

	N(Rt
__future__RtabcR
RRt__all__tobjectRRtregisterR6RR7RRtintR<(((s/usr/lib64/python2.7/numbers.pyt<module>s
�
b
_