Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

�
��f�(c@s�dZd
dl
mZmZ
dddddgZGdd�dd	e�
ZGd
d�de�Zeje�

Gdd�de�Z	e	je
�

Gdd�de	�ZGd
d�de�Zeje
�

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

TODO: Fill out more detailed documentation on the operators.i(uABCMetauabstractmethoduNumberuComplexuRealuRationaluIntegralc


Bs&|EeZ
dZd
ZfZdZdS(uNumberu�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(u__name__u
__module__u__qualname__u__doc__u	__slots__uNoneu__hash__(
u
__locals__((u,/opt/alt/python33/lib64/python3.3/numbers.pyuNumbers
u	metaclassc

Bs|
|EeZ
dZd
ZfZedd��
Zdd�Zeedd��
�
Z	eedd	��
�
Z
ed
d��
Zedd
��
Zedd��
Z
edd��
Zdd�Zdd�Zedd��
Zedd��
Zedd��
Zedd��
Zedd��
Zed d!��
Zed"d#��
Zed$d%��
Zed&d'��
Zd(d)�Zd*S(+uComplexua
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


Csd
S(u<Return a builtin complex instance. Called for complex(self).N((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__complex__-suComplex.__complex__c

Cs
|d
kS(u)True if self != 0. Called for bool(self).i((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__bool__1suComplex.__bool__c


Cs
t�
d
S(uXRetrieve the real component of this number.

        This should subclass Real.
        N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyureal5suComplex.realc


Cs
t�
d
S(u]Retrieve the imaginary component of this number.

        This should subclass Real.
        N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyuimag>suComplex.imagc
Cs
t�
d
S(uself + otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__add__GsuComplex.__add__c
Cs
t�
d
S(uother + selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__radd__LsuComplex.__radd__c


Cs
t�
d
S(u-selfN(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__neg__QsuComplex.__neg__c


Cs
t�
d
S(u+selfN(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__pos__VsuComplex.__pos__cCs	||
S(
uself - other((uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__sub__[suComplex.__sub__cCs	||
S(
uother - self((uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rsub___suComplex.__rsub__c
Cs
t�
d
S(uself * otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__mul__csuComplex.__mul__c
Cs
t�
d
S(uother * selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rmul__hsuComplex.__rmul__c
Cs
t�
d
S(u5self / other: Should promote to float when necessary.N(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__truediv__msuComplex.__truediv__c
Cs
t�
d
S(uother / selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rtruediv__rsuComplex.__rtruediv__c
Cs
t�
d
S(uBself**exponent; should promote to float or complex when necessary.N(
uNotImplementedError(uselfuexponent((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__pow__wsuComplex.__pow__c
Cs
t�
d
S(ubase ** selfN(
uNotImplementedError(uselfubase((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rpow__|suComplex.__rpow__c


Cs
t�
d
S(u7Returns the Real distance from 0. Called for abs(self).N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__abs__�suComplex.__abs__c


Cs
t�
d
S(u$(x+y*i).conjugate() returns (x-y*i).N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	conjugate�suComplex.conjugatec
Cs
t�
d
S(u
self == otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__eq__�suComplex.__eq__cCs||
kS(
u
self != other((uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__ne__�suComplex.__ne__N(u__name__u
__module__u__qualname__u__doc__u	__slots__uabstractmethodu__complex__u__bool__upropertyurealuimagu__add__u__radd__u__neg__u__pos__u__sub__u__rsub__u__mul__u__rmul__u__truediv__u__rtruediv__u__pow__u__rpow__u__abs__u	conjugateu__eq__u__ne__(
u
__locals__((u,/opt/alt/python33/lib64/python3.3/numbers.pyuComplex s0	

c

Bs=
|EeZ
dZd
ZfZedd��
Zedd��
Zedd��
Zedd	��
Z	ed$d
d�
�
Zdd
�Zdd�Z
edd��
Zedd��
Zedd��
Zedd��
Zedd��
Zedd��
Zdd�Zedd��
Zed d!��
Zd"d#�Zd$S(%uRealu�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


Cs
t�
d
S(uTAny Real can be converted to a native float object.

        Called for float(self).N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__float__�suReal.__float__c


Cs
t�
d
S(uG
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(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__trunc__�suReal.__trunc__c


Cs
t�
d
S(u$Finds the greatest Integral <= self.N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__floor__�suReal.__floor__c


Cs
t�
d
S(u!Finds the least Integral >= self.N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__ceil__�su
Real.__ceil__c
Cs
t�
d
S(u�Rounds self to ndigits decimal places, defaulting to 0.

        If ndigits is omitted or None, returns an Integral, otherwise
        returns a Real. Rounds half toward even.
        N(
uNotImplementedError(uselfundigits((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__round__�suReal.__round__cCs||
||
fS(
u�divmod(self, other): The pair (self // other, self % other).

        Sometimes this can be computed faster than the pair of
        operations.
        ((uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu
__divmod__�suReal.__divmod__cCs|
||
|fS(
u�divmod(other, self): The pair (self // other, self % other).

        Sometimes this can be computed faster than the pair of
        operations.
        ((uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rdivmod__�suReal.__rdivmod__c
Cs
t�
d
S(u)self // other: The floor() of self/other.N(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__floordiv__�suReal.__floordiv__c
Cs
t�
d
S(u)other // self: The floor() of other/self.N(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu
__rfloordiv__�suReal.__rfloordiv__c
Cs
t�
d
S(uself % otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__mod__�suReal.__mod__c
Cs
t�
d
S(uother % selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rmod__�su
Real.__rmod__c
Cs
t�
d
S(uRself < other

        < on Reals defines a total ordering, except perhaps for NaN.N(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__lt__�suReal.__lt__c
Cs
t�
d
S(u
self <= otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__le__�suReal.__le__c

Cstt
|�
�
S(
u(complex(self) == complex(float(self), 0)(ucomplexufloat(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__complex__�suReal.__complex__c


Cs|
S(
u&Real numbers are their real component.((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyureal�su	Real.realc


Csd
S(u)Real numbers have no imaginary component.i((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyuimag
su	Real.imagc


Cs|
S(
uConjugate is a no-op for Reals.((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	conjugate	
suReal.conjugateN(u__name__u
__module__u__qualname__u__doc__u	__slots__uabstractmethodu	__float__u	__trunc__u	__floor__u__ceil__uNoneu	__round__u
__divmod__u__rdivmod__u__floordiv__u
__rfloordiv__u__mod__u__rmod__u__lt__u__le__u__complex__upropertyurealuimagu	conjugate(
u
__locals__((u,/opt/alt/python33/lib64/python3.3/numbers.pyuReal�s(

c

Bs\|EeZ
dZd
ZfZeedd��
�
Zeedd��
�
Zdd�Z	dS(	uRationalu6.numerator and .denominator should be in lowest terms.c


Cs
t�
dS(
N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	numerator
suRational.numeratorc


Cs
t�
dS(
N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyudenominator
suRational.denominatorc

Cs|j|j
S(
u
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.

        (u	numeratorudenominator(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__float__ 
suRational.__float__N(
u__name__u
__module__u__qualname__u__doc__u	__slots__upropertyuabstractmethodu	numeratorudenominatoru	__float__(
u
__locals__((u,/opt/alt/python33/lib64/python3.3/numbers.pyuRational
s


c

BsI
|EeZ
dZd
ZfZedd��
Zdd�Zed$dd�
�
Z	edd	��
Z
ed
d��
Zedd
��
Zedd��
Z
edd��
Zedd��
Zedd��
Zedd��
Zedd��
Zedd��
Zedd��
Zdd�Zed d!��
Zed"d#��
Zd$S(%uIntegralu@Integral adds a conversion to int and the bit-string operations.c


Cs
t�
d
S(u	int(self)N(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__int__0
suIntegral.__int__c

Cs
t|�
S(
u6Called whenever an index is needed, such as in slicing(
uint(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__index__5
suIntegral.__index__c
Cs
t�
d
S(u4
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(
uNotImplementedError(uselfuexponentumodulus((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__pow__9
s	uIntegral.__pow__c
Cs
t�
d
S(u
self << otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu
__lshift__D
suIntegral.__lshift__c
Cs
t�
d
S(u
other << selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rlshift__I
suIntegral.__rlshift__c
Cs
t�
d
S(u
self >> otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu
__rshift__N
suIntegral.__rshift__c
Cs
t�
d
S(u
other >> selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rrshift__S
suIntegral.__rrshift__c
Cs
t�
d
S(uself & otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__and__X
suIntegral.__and__c
Cs
t�
d
S(uother & selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rand__]
suIntegral.__rand__c
Cs
t�
d
S(uself ^ otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__xor__b
suIntegral.__xor__c
Cs
t�
d
S(uother ^ selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__rxor__g
suIntegral.__rxor__c
Cs
t�
d
S(uself | otherN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__or__l
suIntegral.__or__c
Cs
t�
d
S(uother | selfN(
uNotImplementedError(uselfuother((u,/opt/alt/python33/lib64/python3.3/numbers.pyu__ror__q
suIntegral.__ror__c


Cs
t�
d
S(u~selfN(
uNotImplementedError(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu
__invert__v
suIntegral.__invert__c

Cstt
|�
�
S(
ufloat(self) == float(int(self))(ufloatuint(
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	__float__|
suIntegral.__float__c


Cs|
S(
u"Integers are their own numerators.((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyu	numerator�
suIntegral.numeratorc


Csd
S(u!Integers have a denominator of 1.i
((
uself((u,/opt/alt/python33/lib64/python3.3/numbers.pyudenominator�
suIntegral.denominatorN(u__name__u
__module__u__qualname__u__doc__u	__slots__uabstractmethodu__int__u	__index__uNoneu__pow__u
__lshift__u__rlshift__u
__rshift__u__rrshift__u__and__u__rand__u__xor__u__rxor__u__or__u__ror__u
__invert__u	__float__upropertyu	numeratorudenominator(
u
__locals__((u,/opt/alt/python33/lib64/python3.3/numbers.pyuIntegral+
s(


N(u__doc__uabcuABCMetauabstractmethodu__all__uNumberuComplexuregisterucomplexuRealufloatuRationaluIntegraluint(((u,/opt/alt/python33/lib64/python3.3/numbers.pyu<module>su
u
_