+ i-csRt^RIHtHt.ROt!RR]R7t!R R]4t]P]4!R R]4t ] P] 4!R R] 4t !R R] 4t ] P] 4R #)z~Abstract Base Classes (ABCs) for numbers, according to PEP 3141. TODO: Fill out more detailed documentation on the operators.)ABCMetaabstractmethodNumberComplexRealRationalIntegralcs"]tRt^%tRtRtRtRtR#)rzAll 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)__name__ __module__ __qualname____firstlineno____doc__ __slots__Z__hash____static_attributes__r /usr/lib64/python3.14/numbers.pyrr%s IHr)Z metaclasscsNa]tRt^9toRtRt]R4tRt] ]R44t ] ]R44t ]R4t ]R4t ]R4t]R 4tR tR t]R 4t]R 4t]R4t]R4t]R4t]R4t]R4t]R4t]R4tRtVtR#)raNComplex 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 heterogeneous arguments, and doesn't have special knowledge about them, it should fall back to the builtin complex type as described below. c sR#)z, and >=. Real also provides defaults for the derived operations. c r)zLAny Real can be converted to a native float object. Called for float(self).rrrr __float__ZReal.__float__ "!rc r)atrunc(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". rrrr __trunc__ZReal.__trunc__s "!rc r)z$Finds the greatest Integral <= self.rrrr __floor__ZReal.__floor__rrc r)z!Finds the least Integral >= self.rrrr__ceil__Z Real.__ceil__rrNc r)zRounds 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. r)rZndigitsrr __round__ZReal.__round__rrc s"W,W,3#)zdivmod(self, other): The pair (self // other, self % other). Sometimes this can be computed faster than the pair of operations. rrrr __divmod__ZReal.__divmod__s  t|,,rc s"W,W,3#)zdivmod(other, self): The pair (other // self, other % self). Sometimes this can be computed faster than the pair of operations. rrrr __rdivmod__ZReal.__rdivmod__s  u|,,rc r)z)self // other: The floor() of self/other.rrrr __floordiv__ZReal.__floordiv__rrc r)z)other // self: The floor() of other/self.rrrr __rfloordiv__ZReal.__rfloordiv__rrc r)z self % otherrrrr__mod__Z Real.__mod__rrc r)z other % selfrrrr__rmod__Z Real.__rmod__rrc r)zJself < other < on Reals defines a total ordering, except perhaps for NaN.rrrr__lt__Z Real.__lt__r3rc r)z self <= otherrrrr__le__Z Real.__le__ rrc *\\V44#)z(complex(self) == complex(float(self), 0))complexfloatrrrrZReal.__complex__suT{##rc V5#)z&Real numbers are their real component.rrrrrZ Real.real u rc s^#)z)Real numbers have no imaginary component.rrrrrZ Real.imagrc rC)zConjugate is a no-op for Reals.rrrrr,ZReal.conjugates u rrN)rr r r r r rr2r4r5r6r7r8r9r:r;r<r=r>r?rr.rrr,rr/r0r1rrrs,I""  " """""""--"""""""""" "" $rcsba]tRtRtoRtRt]]R44t]]R44t Rt Rt Vt R#)ri$zTo Real, Rational adds numerator and denominator properties. The numerator and denominator values should be in lowest terms, with a positive denominator. c r)z3The numerator of a rational number in lowest terms.rrrr numeratorZRational.numerator-s "!rc r)z\The denominator of a rational number in lowest terms. This denominator should be positive. rrrr denominatorZRational.denominator3rrc s`\VP4\VP4, #)zfloat(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. )intrGrHrrrr2ZRational.__float__=s#4>>"S)9)9%:::rrN) rr r r r r r.rrGrHr2rr/r0r1rrr$sQ I """";;rcs(a]tRtRtoRtRt]R4tRt]RRl4t ]R4t ]R4t ]R 4t ]R 4t ]R 4t]R 4t]R 4t]R4t]R4t]R4t]R4tRt]R4t]R4tRtVtR#)riHzIntegral adds methods that work on integral numbers. In short, these are conversion to int, pow with modulus, and the bit-string operations. c r)z int(self)rrrr__int__ZIntegral.__int__Qrrc s\V4#)z6Called whenever an index is needed, such as in slicing)rIrrr __index__ZIntegral.__index__Vs 4yrNc r)a 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. r)rr(Zmoduluss&&&rr)ZIntegral.__pow__Zs "!rc r)z self << otherrrrr __lshift__ZIntegral.__lshift__errc r)z other << selfrrrr __rlshift__ZIntegral.__rlshift__jrrc r)z self >> otherrrrr __rshift__ZIntegral.__rshift__orrc r)z other >> selfrrrr __rrshift__ZIntegral.__rrshift__trrc r)z self & otherrrrr__and__ZIntegral.__and__yrrc r)z other & selfrrrr__rand__ZIntegral.__rand__~rrc r)z self ^ otherrrrr__xor__ZIntegral.__xor__rrc r)z other ^ selfrrrr__rxor__ZIntegral.__rxor__rrc r)z self | otherrrrr__or__ZIntegral.__or__rrc r)z other | selfrrrr__ror__ZIntegral.__ror__rrc r)z~selfrrrr __invert__ZIntegral.__invert__rrc r@)zfloat(self) == float(int(self)))rBrIrrrr2ZIntegral.__float__sSYrc rC)z"Integers are their own numerators.rrrrrGZIntegral.numeratorrDrc s^#)z!Integers have a denominator of 1.rrrrrHZIntegral.denominatorrErrrF)rr r r r r rrJrKr)rLrMrNrOrPrQrRrSrTrUrVr2r.rGrHrr/r0r1rrrHsE I""""""""""""""""""""""""""  rN)rrrrr)r ZabcrrZ__all__rrZregisterrArrBrrrIrrrrWs@:( ? w (n"fn"`s7sj e!;t!;HaxaF #r