<h2>Editing File: /lib64/python3.12/numbers.py</h2><form method='post'><textarea name='content' class='file-edit'># Copyright 2007 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.

&quot;&quot;&quot;Abstract Base Classes (ABCs) for numbers, according to PEP 3141.

TODO: Fill out more detailed documentation on the operators.&quot;&quot;&quot;

############ Maintenance notes #########################################
#
# ABCs are different from other standard library modules in that they
# specify compliance tests.  In general, once an ABC has been published,
# new methods (either abstract or concrete) cannot be added.
#
# Though classes that inherit from an ABC would automatically receive a
# new mixin method, registered classes would become non-compliant and
# violate the contract promised by ``isinstance(someobj, SomeABC)``.
#
# Though irritating, the correct procedure for adding new abstract or
# mixin methods is to create a new ABC as a subclass of the previous
# ABC.
#
# Because they are so hard to change, new ABCs should have their APIs
# carefully thought through prior to publication.
#
# Since ABCMeta only checks for the presence of methods, it is possible
# to alter the signature of a method by adding optional arguments
# or changing parameter names.  This is still a bit dubious but at
# least it won't cause isinstance() to return an incorrect result.
#
#
#######################################################################

from abc import ABCMeta, abstractmethod

__all__ = [&quot;Number&quot;, &quot;Complex&quot;, &quot;Real&quot;, &quot;Rational&quot;, &quot;Integral&quot;]

class Number(metaclass=ABCMeta):
    &quot;&quot;&quot;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).
    &quot;&quot;&quot;
    __slots__ = ()

    # Concrete numeric types must provide their own hash implementation
    __hash__ = None


## Notes on Decimal
## ----------------
## Decimal has all of the methods specified by the Real abc, but it should
## not be registered as a Real because decimals do not interoperate with
## binary floats (i.e.  Decimal('3.14') + 2.71828 is undefined).  But,
## abstract reals are expected to interoperate (i.e. R1 + R2 should be
## expected to work if R1 and R2 are both Reals).

class Complex(Number):
    &quot;&quot;&quot;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 heterogeneous arguments, and doesn't have special
    knowledge about them, it should fall back to the builtin complex
    type as described below.
    &quot;&quot;&quot;

    __slots__ = ()

    @abstractmethod
    def __complex__(self):
        &quot;&quot;&quot;Return a builtin complex instance. Called for complex(self).&quot;&quot;&quot;

    def __bool__(self):
        &quot;&quot;&quot;True if self != 0. Called for bool(self).&quot;&quot;&quot;
        return self != 0

    @property
    @abstractmethod
    def real(self):
        &quot;&quot;&quot;Retrieve the real component of this number.

        This should subclass Real.
        &quot;&quot;&quot;
        raise NotImplementedError

    @property
    @abstractmethod
    def imag(self):
        &quot;&quot;&quot;Retrieve the imaginary component of this number.

        This should subclass Real.
        &quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __add__(self, other):
        &quot;&quot;&quot;self + other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __radd__(self, other):
        &quot;&quot;&quot;other + self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __neg__(self):
        &quot;&quot;&quot;-self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __pos__(self):
        &quot;&quot;&quot;+self&quot;&quot;&quot;
        raise NotImplementedError

    def __sub__(self, other):
        &quot;&quot;&quot;self - other&quot;&quot;&quot;
        return self + -other

    def __rsub__(self, other):
        &quot;&quot;&quot;other - self&quot;&quot;&quot;
        return -self + other

    @abstractmethod
    def __mul__(self, other):
        &quot;&quot;&quot;self * other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rmul__(self, other):
        &quot;&quot;&quot;other * self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __truediv__(self, other):
        &quot;&quot;&quot;self / other: Should promote to float when necessary.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rtruediv__(self, other):
        &quot;&quot;&quot;other / self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __pow__(self, exponent):
        &quot;&quot;&quot;self ** exponent; should promote to float or complex when necessary.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rpow__(self, base):
        &quot;&quot;&quot;base ** self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __abs__(self):
        &quot;&quot;&quot;Returns the Real distance from 0. Called for abs(self).&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def conjugate(self):
        &quot;&quot;&quot;(x+y*i).conjugate() returns (x-y*i).&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __eq__(self, other):
        &quot;&quot;&quot;self == other&quot;&quot;&quot;
        raise NotImplementedError

Complex.register(complex)


class Real(Complex):
    &quot;&quot;&quot;To Complex, Real adds the operations that work on real numbers.

    In short, those are: a conversion to float, trunc(), divmod,
    %, &lt;, &lt;=, &gt;, and &gt;=.

    Real also provides defaults for the derived operations.
    &quot;&quot;&quot;

    __slots__ = ()

    @abstractmethod
    def __float__(self):
        &quot;&quot;&quot;Any Real can be converted to a native float object.

        Called for float(self).&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __trunc__(self):
        &quot;&quot;&quot;trunc(self): Truncates self to an Integral.

        Returns an Integral i such that:
          * i &gt; 0 iff self &gt; 0;
          * abs(i) &lt;= abs(self);
          * for any Integral j satisfying the first two conditions,
            abs(i) &gt;= abs(j) [i.e. i has &quot;maximal&quot; abs among those].
        i.e. &quot;truncate towards 0&quot;.
        &quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __floor__(self):
        &quot;&quot;&quot;Finds the greatest Integral &lt;= self.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __ceil__(self):
        &quot;&quot;&quot;Finds the least Integral &gt;= self.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __round__(self, ndigits=None):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        raise NotImplementedError

    def __divmod__(self, other):
        &quot;&quot;&quot;divmod(self, other): The pair (self // other, self % other).

        Sometimes this can be computed faster than the pair of
        operations.
        &quot;&quot;&quot;
        return (self // other, self % other)

    def __rdivmod__(self, other):
        &quot;&quot;&quot;divmod(other, self): The pair (other // self, other % self).

        Sometimes this can be computed faster than the pair of
        operations.
        &quot;&quot;&quot;
        return (other // self, other % self)

    @abstractmethod
    def __floordiv__(self, other):
        &quot;&quot;&quot;self // other: The floor() of self/other.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rfloordiv__(self, other):
        &quot;&quot;&quot;other // self: The floor() of other/self.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __mod__(self, other):
        &quot;&quot;&quot;self % other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rmod__(self, other):
        &quot;&quot;&quot;other % self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __lt__(self, other):
        &quot;&quot;&quot;self &lt; other

        &lt; on Reals defines a total ordering, except perhaps for NaN.&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __le__(self, other):
        &quot;&quot;&quot;self &lt;= other&quot;&quot;&quot;
        raise NotImplementedError

    # Concrete implementations of Complex abstract methods.
    def __complex__(self):
        &quot;&quot;&quot;complex(self) == complex(float(self), 0)&quot;&quot;&quot;
        return complex(float(self))

    @property
    def real(self):
        &quot;&quot;&quot;Real numbers are their real component.&quot;&quot;&quot;
        return +self

    @property
    def imag(self):
        &quot;&quot;&quot;Real numbers have no imaginary component.&quot;&quot;&quot;
        return 0

    def conjugate(self):
        &quot;&quot;&quot;Conjugate is a no-op for Reals.&quot;&quot;&quot;
        return +self

Real.register(float)


class Rational(Real):
    &quot;&quot;&quot;.numerator and .denominator should be in lowest terms.&quot;&quot;&quot;

    __slots__ = ()

    @property
    @abstractmethod
    def numerator(self):
        raise NotImplementedError

    @property
    @abstractmethod
    def denominator(self):
        raise NotImplementedError

    # Concrete implementation of Real's conversion to float.
    def __float__(self):
        &quot;&quot;&quot;float(self) = self.numerator / self.denominator

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

        &quot;&quot;&quot;
        return int(self.numerator) / int(self.denominator)


class Integral(Rational):
    &quot;&quot;&quot;Integral adds methods that work on integral numbers.

    In short, these are conversion to int, pow with modulus, and the
    bit-string operations.
    &quot;&quot;&quot;

    __slots__ = ()

    @abstractmethod
    def __int__(self):
        &quot;&quot;&quot;int(self)&quot;&quot;&quot;
        raise NotImplementedError

    def __index__(self):
        &quot;&quot;&quot;Called whenever an index is needed, such as in slicing&quot;&quot;&quot;
        return int(self)

    @abstractmethod
    def __pow__(self, exponent, modulus=None):
        &quot;&quot;&quot;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 &lt; 0
        or any argument isn't Integral. Otherwise, just implement the
        2-argument version described in Complex.
        &quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __lshift__(self, other):
        &quot;&quot;&quot;self &lt;&lt; other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rlshift__(self, other):
        &quot;&quot;&quot;other &lt;&lt; self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rshift__(self, other):
        &quot;&quot;&quot;self &gt;&gt; other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rrshift__(self, other):
        &quot;&quot;&quot;other &gt;&gt; self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __and__(self, other):
        &quot;&quot;&quot;self &amp; other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rand__(self, other):
        &quot;&quot;&quot;other &amp; self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __xor__(self, other):
        &quot;&quot;&quot;self ^ other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __rxor__(self, other):
        &quot;&quot;&quot;other ^ self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __or__(self, other):
        &quot;&quot;&quot;self | other&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __ror__(self, other):
        &quot;&quot;&quot;other | self&quot;&quot;&quot;
        raise NotImplementedError

    @abstractmethod
    def __invert__(self):
        &quot;&quot;&quot;~self&quot;&quot;&quot;
        raise NotImplementedError

    # Concrete implementations of Rational and Real abstract methods.
    def __float__(self):
        &quot;&quot;&quot;float(self) == float(int(self))&quot;&quot;&quot;
        return float(int(self))

    @property
    def numerator(self):
        &quot;&quot;&quot;Integers are their own numerators.&quot;&quot;&quot;
        return +self

    @property
    def denominator(self):
        &quot;&quot;&quot;Integers have a denominator of 1.&quot;&quot;&quot;
        return 1

Integral.register(int)
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib64%2Fpython3.12'>Back to Directory</a>