grthtrhthjhtyjytjytkergtrhtrjytjerhrfh4:24 29/09/2026+ ik`Rt^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.)ABCMetaabstractmethodNumberComplexRealRationalIntegralc"]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____hash____static_attributes__r ./opt/alt/python314/lib64/python3.14/numbers.pyrr%s IHr) metaclasscNa]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 R#)zrArDrGrKrOrRrUrXr__classdictcell__ __classdict__s@rrr9spIKK""""""""""""""""""""""""""""""rca]tRt^toRtRt]R4t]R4t]R4t ]R4t ]RRl4t Rt R t ]R 4t]R 4t]R 4t]R 4t]R4t]R4tRt]R4t]R4tRtRtVtR#)rzTo 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 \h)zLAny Real can be converted to a native float object. Called for float(self).r rs&r __float__Real.__float__ "!rc \h)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". r rs&r __trunc__Real.__trunc__s "!rc \h)z$Finds the greatest Integral <= self.r rs&r __floor__Real.__floor__r-rc \h)z!Finds the least Integral >= self.r rs&r__ceil__ Real.__ceil__r-rNc \h)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 )rndigitss&&r __round__Real.__round__r$rc "W,W,3#)zdivmod(self, other): The pair (self // other, self % other). Sometimes this can be computed faster than the pair of operations. r r)s&&r __divmod__Real.__divmod__s  t|,,rc "W,W,3#)zdivmod(other, self): The pair (other // self, other % self). Sometimes this can be computed faster than the pair of operations. r r)s&&r __rdivmod__Real.__rdivmod__s  u|,,rc \h)z)self // other: The floor() of self/other.r r)s&&r __floordiv__Real.__floordiv__r-rc \h)z)other // self: The floor() of other/self.r r)s&&r __rfloordiv__Real.__rfloordiv__r-rc \h)z self % otherr r)s&&r__mod__ Real.__mod__r-rc \h)z other % selfr r)s&&r__rmod__ Real.__rmod__r-rc \h)zJself < other < on Reals defines a total ordering, except perhaps for NaN.r r)s&&r__lt__ Real.__lt__rbrc \h)z self <= otherr r)s&&r__le__ Real.__le__ r-rc *\\V44#)z(complex(self) == complex(float(self), 0))complexfloatrs&rrReal.__complex__suT{##rc V5#)z&Real numbers are their real component.r rs&rr" Real.real u rc ^#)z)Real numbers have no imaginary component.r rs&rr& Real.imagrc V5#)zConjugate is a no-op for Reals.r rs&rrUReal.conjugates u rr N)r r r rrrrr`rdrgrjrnrqrtrwrzr}rrrrrZr"r&rUrr[r\s@rrrs,I""  " """""""--"""""""""" "" $rcba]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 \h)z3The numerator of a rational number in lowest terms.r rs&r numeratorRational.numerator-s "!rc \h)z\The denominator of a rational number in lowest terms. This denominator should be positive. r rs&r denominatorRational.denominator3r$rc `\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. )intrrrs&rr`Rational.__float__=s#4>>"S)9)9%:::rr N) r r r rrrrZrrrr`rr[r\s@rrr$sQ I """";;rc(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 \h)z int(self)r rs&r__int__Integral.__int__Qr-rc \V4#)z6Called whenever an index is needed, such as in slicing)rrs&r __index__Integral.__index__Vs 4yrNc \h)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 )rrJmoduluss&&&rrKIntegral.__pow__Zs "!rc \h)z self << otherr r)s&&r __lshift__Integral.__lshift__er-rc \h)z other << selfr r)s&&r __rlshift__Integral.__rlshift__jr-rc \h)z self >> otherr r)s&&r __rshift__Integral.__rshift__or-rc \h)z other >> selfr r)s&&r __rrshift__Integral.__rrshift__tr-rc \h)z self & otherr r)s&&r__and__Integral.__and__yr-rc \h)z other & selfr r)s&&r__rand__Integral.__rand__~r-rc \h)z self ^ otherr r)s&&r__xor__Integral.__xor__r-rc \h)z other ^ selfr r)s&&r__rxor__Integral.__rxor__r-rc \h)z self | otherr r)s&&r__or__Integral.__or__r-rc \h)z other | selfr r)s&&r__ror__Integral.__ror__r-rc \h)z~selfr rs&r __invert__Integral.__invert__r-rc *\\V44#)zfloat(self) == float(int(self)))rrrs&rr`Integral.__float__sSYrc V5#)z"Integers are their own numerators.r rs&rrIntegral.numeratorrrc ^#)z!Integers have a denominator of 1.r rs&rrIntegral.denominatorrrr r)r r r rrrrrrrKrrrrrrrrrrrr`rZrrrr[r\s@rrrHsE I""""""""""""""""""""""""""  rN)rrrrr)rabcrr__all__rrregisterrrrrrrr rrrs@:( ? w (n"fn"`s7sj e!;t!;HaxaF #r