
    XhL                    |   d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ  G d de          Z G d de          Z G d de          Z G d d          Z G d dee          Z e            xZe_         G d dee          Z e            xZe_        dS )zDomains of Gaussian type.    )annotations)I)DMP)CoercionFailed)ZZ)QQ)AlgebraicField)Domain)DomainElement)Field)Ringc                       e Zd ZU dZded<   ded<   dZddZe fd            Zd	 Z	d
 Z
d Zd Zd Zd Zd Zd Zed             Zd ZeZd Zd Zd ZeZd Zd Zd Zd Zd Zd Zd Zd Zd Z  xZ!S ) GaussianElementz1Base class for elements of Gaussian type domains.r
   base_parent)xyr   c                j    | j         j        }|                      ||           ||                    S N)r   convertnew)clsr   r   convs       u/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/sympy/polys/domains/gaussiandomains.py__new__zGaussianElement.__new__   s0    xwwttAwwQ(((    c                f    t                                          |           }||_        ||_        |S )z0Create a new GaussianElement of the same domain.)superr   r   r   )r   r   r   obj	__class__s       r   r   zGaussianElement.new   s-     ggooc""
r   c                    | j         S )z4The domain that this is an element of (ZZ_I or QQ_I))r   selfs    r   parentzGaussianElement.parent#   s
    |r   c                8    t          | j        | j        f          S r   )hashr   r   r"   s    r   __hash__zGaussianElement.__hash__'   s    TVTV$%%%r   c                z    t          || j                  r | j        |j        k    o| j        |j        k    S t          S r   )
isinstancer    r   r   NotImplementedr#   others     r   __eq__zGaussianElement.__eq__*   s9    eT^,, 	"6UW$:57)::!!r   c                v    t          |t                    st          S | j        | j        g|j        |j        gk     S r   )r)   r   r*   r   r   r+   s     r   __lt__zGaussianElement.__lt__0   s7    %11 	"!!57EG"444r   c                    | S r    r"   s    r   __pos__zGaussianElement.__pos__5   s    r   c                F    |                      | j         | j                   S r   r   r   r   r"   s    r   __neg__zGaussianElement.__neg__8   s    xx$&)))r   c                @    | j         j        d| j        d| j        dS )N(z, ))r   repr   r   r"   s    r   __repr__zGaussianElement.__repr__;   s&    #|///@@r   c                P    t          | j                            |                     S r   )strr   to_sympyr"   s    r   __str__zGaussianElement.__str__>   s     4<((..///r   c                    t          ||           s-	 | j                            |          }n# t          $ r Y dS w xY w|j        |j        fS )N)NN)r)   r   r   r   r   r   )r   r,   s     r   _get_xyzGaussianElement._get_xyA   sa    %%% 	""++E22! " " "!zz"ws   - 
;;c                    |                      |          \  }}|&|                     | j        |z   | j        |z             S t          S r   r@   r   r   r   r*   r#   r,   r   r   s       r   __add__zGaussianElement.__add__J   B    ||E""1=88DFQJ
333!!r   c                    |                      |          \  }}|&|                     | j        |z
  | j        |z
            S t          S r   rB   rC   s       r   __sub__zGaussianElement.__sub__S   rE   r   c                    |                      |          \  }}|&|                     || j        z
  || j        z
            S t          S r   rB   rC   s       r   __rsub__zGaussianElement.__rsub__Z   sB    ||E""1=88AJDF
333!!r   c                    |                      |          \  }}|<|                     | j        |z  | j        |z  z
  | j        |z  | j        |z  z             S t          S r   rB   rC   s       r   __mul__zGaussianElement.__mul__a   sX    ||E""1=88DF1Htvax/DF1H1DEEE!!r   c                    |dk    r|                      dd          S |dk     rd| z  | }} |dk    r| S | }|dz  r| n| j        j        }|dz  }|r||z  }|dz  r||z  }|dz  }||S )Nr         )r   r   one)r#   exppow2prods       r   __pow__zGaussianElement.__pow__j   s    !8888Aq>>!77$#D!88KQw4ttDL$4	 	DLDQw AIC	  	
 r   c                R    t          | j                  pt          | j                  S r   )boolr   r   r"   s    r   __bool__zGaussianElement.__bool__{   s    DF||+tDF||+r   c                    | j         dk    r| j        dk    rdndS | j         dk     r| j        dk     rdndS | j        dk    rdndS )zIReturn quadrant index 0-3.

        0 is included in quadrant 0.
        r   rM   rN      )r   r   r"   s    r   quadrantzGaussianElement.quadrant~   sV    
 6A::

11)VaZZ

11)!11*r   c                    	 | j                             |          }|                    |           S # t          $ r
 t          cY S w xY wr   )r   r   
__divmod__r   r*   r+   s     r   __rdivmod__zGaussianElement.__rdivmod__   s[    	*L((//E ##D)))  	" 	" 	"!!!!	"   1 AAc                    	 t                               |          }|                    |           S # t          $ r
 t          cY S w xY wr   )QQ_Ir   __truediv__r   r*   r+   s     r   __rtruediv__zGaussianElement.__rtruediv__   sW    	+LL''E $$T***  	" 	" 	"!!!!	"r]   c                R    |                      |          }|t          u r|n|d         S Nr   r[   r*   r#   r,   qrs      r   __floordiv__zGaussianElement.__floordiv__   +    __U##>))rrr!u4r   c                R    |                      |          }|t          u r|n|d         S rc   r\   r*   re   s      r   __rfloordiv__zGaussianElement.__rfloordiv__   -    e$$>))rrr!u4r   c                R    |                      |          }|t          u r|n|d         S NrM   rd   re   s      r   __mod__zGaussianElement.__mod__   rh   r   c                R    |                      |          }|t          u r|n|d         S rn   rj   re   s      r   __rmod__zGaussianElement.__rmod__   rl   r   )r   )"__name__
__module____qualname____doc____annotations__	__slots__r   classmethodr   r$   r'   r-   r/   r2   r5   r:   r>   r@   rD   __radd__rG   rI   rK   __rmul__rS   rV   rY   r\   ra   rg   rk   ro   rq   __classcell__)r    s   @r   r   r      s        ;;LLLOOOI) ) ) )     [  & & &" " "5 5 5
  * * *A A A0 0 0     [ " " " H" " "" " "" " " H  ", , ,
+ 
+ 
+* * *+ + +5 5 55 5 55 5 55 5 5 5 5 5 5r   r   c                  "    e Zd ZdZeZd Zd ZdS )GaussianIntegerzGaussian integer: domain element for :ref:`ZZ_I`

        >>> from sympy import ZZ_I
        >>> z = ZZ_I(2, 3)
        >>> z
        (2 + 3*I)
        >>> type(z)
        <class 'sympy.polys.domains.gaussiandomains.GaussianInteger'>
    c                <    t                               |           |z  S )Return a Gaussian rational.)r_   r   r+   s     r   r`   zGaussianInteger.__truediv__   s    ||D!!%''r   c                d   |s"t          d                    |                     |                     |          \  }}|t          S | j        |z  | j        |z  z   | j         |z  | j        |z  z   }}||z  ||z  z   }d|z  |z   d|z  z  }d|z  |z   d|z  z  }t          ||          }	|	| |	|z  z
  fS )Nzdivmod({}, 0)rN   )ZeroDivisionErrorformatr@   r*   r   r   r}   )
r#   r,   r   r   abcqxqyqs
             r   r[   zGaussianInteger.__divmod__   s     	B#O$:$:4$@$@AAA||E""19!! vax$&("TVGAIq$81aC!A#I cAg1Q3cAg1Q3B## $5.  r   N)rr   rs   rt   ru   r   r   r`   r[   r1   r   r   r}   r}      sC          D( ( (! ! ! ! !r   r}   c                  "    e Zd ZdZeZd Zd ZdS )GaussianRationala  Gaussian rational: domain element for :ref:`QQ_I`

        >>> from sympy import QQ_I, QQ
        >>> z = QQ_I(QQ(2, 3), QQ(4, 5))
        >>> z
        (2/3 + 4/5*I)
        >>> type(z)
        <class 'sympy.polys.domains.gaussiandomains.GaussianRational'>
    c                   |s"t          d                    |                     |                     |          \  }}|t          S ||z  ||z  z   }t	          | j        |z  | j        |z  z   |z  | j         |z  | j        |z  z   |z            S )r   z{} / 0)r   r   r@   r*   r   r   r   )r#   r,   r   r   r   s        r   r`   zGaussianRational.__truediv__   s     	;#HOOD$9$9:::||E""19!!aC!A#IDF1H!4a 7"&&TVAX!5q 8: : 	:r   c                    	 | j                             |          }n# t          $ r
 t          cY S w xY w|s"t	          d                    |                     | |z  t          j        fS )Nz{} % 0)r   r   r   r*   r   r   r_   zeror+   s     r   r[   zGaussianRational.__divmod__   sx    	"L((//EE 	" 	" 	"!!!!	" 	)#HOOD$9$9::::ty((s    11N)rr   rs   rt   ru   r   r   r`   r[   r1   r   r   r   r      sC          D
: 
: 
:) ) ) ) )r   r   c                      e Zd ZU dZded<   dZdZdZdZd Z	d Z
d Zd Zd	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd ZdS )GaussianDomainz Base class for Gaussian domains.r
   domTc                l    | j         j        } ||j                  t           ||j                  z  z   S )z!Convert ``a`` to a SymPy object. )r   r=   r   r   r   )r#   r   r   s      r   r=   zGaussianDomain.to_sympy   s/    x tACyy1TT!#YY;&&r   c                x   |                                 \  }}| j                            |          }|s|                     |d          S |                                \  }}| j                            |          }|t
          u r|                     ||          S t          d                    |                    )z)Convert a SymPy object to ``self.dtype``.r   z{} is not Gaussian)as_coeff_Addr   
from_sympyr   as_coeff_Mulr   r   r   )r#   r   rr   r   r   s         r   r   zGaussianDomain.from_sympy  s    ~~1H"" 	"88Aq>>!~~1H""6688Aq>>! !5!<!<Q!?!?@@@r   c                     | j         | S )z$Inject generators into this domain. )	poly_ring)r#   genss     r   injectzGaussianDomain.inject  s    t~t$$r   c                F    | j         |                                          }|S r   )unitsrY   )r#   dunits      r   canonical_unitzGaussianDomain.canonical_unit  s    z1::<<-(r   c                    dS z/Returns ``False`` for any ``GaussianElement``. Fr1   r#   elements     r   is_negativezGaussianDomain.is_negative      ur   c                    dS r   r1   r   s     r   is_positivezGaussianDomain.is_positive  r   r   c                    dS r   r1   r   s     r   is_nonnegativezGaussianDomain.is_nonnegative"  r   r   c                    dS r   r1   r   s     r   is_nonpositivezGaussianDomain.is_nonpositive&  r   r   c                     | |          S )z%Convert a GMPY mpz to ``self.dtype``.r1   K1r   K0s      r   from_ZZ_gmpyzGaussianDomain.from_ZZ_gmpy*      r!uur   c                     | |          S z.Convert a ZZ_python element to ``self.dtype``.r1   r   s      r   from_ZZzGaussianDomain.from_ZZ.  r   r   c                     | |          S r   r1   r   s      r   from_ZZ_pythonzGaussianDomain.from_ZZ_python2  r   r   c                     | |          S z%Convert a GMPY mpq to ``self.dtype``.r1   r   s      r   from_QQzGaussianDomain.from_QQ6  r   r   c                     | |          S r   r1   r   s      r   from_QQ_gmpyzGaussianDomain.from_QQ_gmpy:  r   r   c                     | |          S )z.Convert a QQ_python element to ``self.dtype``.r1   r   s      r   from_QQ_pythonzGaussianDomain.from_QQ_python>  r   r   c                    |j         j        d         t          k    r(|                     |                    |                    S dS )z9Convert an element from ZZ<I> or QQ<I> to ``self.dtype``.r   N)extargsr   r   r=   r   s      r   from_AlgebraicFieldz"GaussianDomain.from_AlgebraicFieldB  s9    6;q>Q==Q000 r   N)rr   rs   rt   ru   rv   is_Numericalis_Exacthas_assoc_Ringhas_assoc_Fieldr=   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r1   r   r   r   r      s        **KKKLHNO' ' '
A A A% % %                      1 1 1 1 1r   r   c                     e Zd ZdZeZ eej        ej        ej        ge          Z	e
Z e ed           ed                    Z e ed           ed                    Z e ed           ed                    Zeee e fZdZdZdZdZd Zd Zd Zed	             Zd
 Zd Zd Zd Zd Zd Zd Zd Zd ZdS )GaussianIntegerRinga{
  Ring of Gaussian integers ``ZZ_I``

    The :ref:`ZZ_I` domain represents the `Gaussian integers`_ `\mathbb{Z}[i]`
    as a :py:class:`~.Domain` in the domain system (see
    :ref:`polys-domainsintro`).

    By default a :py:class:`~.Poly` created from an expression with
    coefficients that are combinations of integers and ``I`` (`\sqrt{-1}`)
    will have the domain :ref:`ZZ_I`.

    >>> from sympy import Poly, Symbol, I
    >>> x = Symbol('x')
    >>> p = Poly(x**2 + I)
    >>> p
    Poly(x**2 + I, x, domain='ZZ_I')
    >>> p.domain
    ZZ_I

    The :ref:`ZZ_I` domain can be used to factorise polynomials that are
    reducible over the Gaussian integers.

    >>> from sympy import factor
    >>> factor(x**2 + 1)
    x**2 + 1
    >>> factor(x**2 + 1, domain='ZZ_I')
    (x - I)*(x + I)

    The corresponding `field of fractions`_ is the domain of the Gaussian
    rationals :ref:`QQ_I`. Conversely :ref:`ZZ_I` is the `ring of integers`_
    of :ref:`QQ_I`.

    >>> from sympy import ZZ_I, QQ_I
    >>> ZZ_I.get_field()
    QQ_I
    >>> QQ_I.get_ring()
    ZZ_I

    When using the domain directly :ref:`ZZ_I` can be used as a constructor.

    >>> ZZ_I(3, 4)
    (3 + 4*I)
    >>> ZZ_I(5)
    (5 + 0*I)

    The domain elements of :ref:`ZZ_I` are instances of
    :py:class:`~.GaussianInteger` which support the rings operations
    ``+,-,*,**``.

    >>> z1 = ZZ_I(5, 1)
    >>> z2 = ZZ_I(2, 3)
    >>> z1
    (5 + 1*I)
    >>> z2
    (2 + 3*I)
    >>> z1 + z2
    (7 + 4*I)
    >>> z1 * z2
    (7 + 17*I)
    >>> z1 ** 2
    (24 + 10*I)

    Both floor (``//``) and modulo (``%``) division work with
    :py:class:`~.GaussianInteger` (see the :py:meth:`~.Domain.div` method).

    >>> z3, z4 = ZZ_I(5), ZZ_I(1, 3)
    >>> z3 // z4  # floor division
    (1 + -1*I)
    >>> z3 % z4   # modulo division (remainder)
    (1 + -2*I)
    >>> (z3//z4)*z4 + z3%z4 == z3
    True

    True division (``/``) in :ref:`ZZ_I` gives an element of :ref:`QQ_I`. The
    :py:meth:`~.Domain.exquo` method can be used to divide in :ref:`ZZ_I` when
    exact division is possible.

    >>> z1 / z2
    (1 + -1*I)
    >>> ZZ_I.exquo(z1, z2)
    (1 + -1*I)
    >>> z3 / z4
    (1/2 + -3/2*I)
    >>> ZZ_I.exquo(z3, z4)
    Traceback (most recent call last):
        ...
    ExactQuotientFailed: (1 + 3*I) does not divide (5 + 0*I) in ZZ_I

    The :py:meth:`~.Domain.gcd` method can be used to compute the `gcd`_ of any
    two elements.

    >>> ZZ_I.gcd(ZZ_I(10), ZZ_I(2))
    (2 + 0*I)
    >>> ZZ_I.gcd(ZZ_I(5), ZZ_I(2, 1))
    (2 + 1*I)

    .. _Gaussian integers: https://en.wikipedia.org/wiki/Gaussian_integer
    .. _gcd: https://en.wikipedia.org/wiki/Greatest_common_divisor

    r   rM   ZZ_ITc                    dS )zFor constructing ZZ_I.Nr1   r"   s    r   __init__zGaussianIntegerRing.__init__        r   c                >    t          |t                    rdS t          S z0Returns ``True`` if two domains are equivalent. T)r)   r   r*   r+   s     r   r-   zGaussianIntegerRing.__eq__  s     e011 	"4!!r   c                     t          d          S )Compute hash code of ``self``. r   r&   r"   s    r   r'   zGaussianIntegerRing.__hash__      F||r   c                    dS NTr1   r"   s    r   has_CharacteristicZeroz*GaussianIntegerRing.has_CharacteristicZero      tr   c                    dS rc   r1   r"   s    r   characteristicz"GaussianIntegerRing.characteristic      qr   c                    | S z)Returns a ring associated with ``self``. r1   r"   s    r   get_ringzGaussianIntegerRing.get_ring      r   c                    t           S z*Returns a field associated with ``self``. )r_   r"   s    r   	get_fieldzGaussianIntegerRing.get_field      r   c                    |                      |          |z  }t          fd|D                       }|r|f|z   n|S )zReturn first quadrant element associated with ``d``.

        Also multiply the other arguments by the same power of i.
        c              3  "   K   | ]	}|z  V  
d S r   r1   ).0r   r   s     r   	<genexpr>z0GaussianIntegerRing.normalize.<locals>.<genexpr>  s'      **QtV******r   )r   tuple)r#   r   r   r   s      @r   	normalizezGaussianIntegerRing.normalize  sX    
 ""1%%	T	****T*****")td{{)r   c                B    |r	|||z  }}|	|                      |          S )z-Greatest common divisor of a and b over ZZ_I.)r   r#   r   r   s      r   gcdzGaussianIntegerRing.gcd  s3     	a!eqA  	~~a   r   c                    | j         }| j        }| j        }| j         }|r%||z  }||||z  z
  }}||||z  z
  }}||||z  z
  }}|%|                     |||          \  }}}|||fS )z6Return x, y, g such that x * a + y * b = g = gcd(a, b))rO   r   r   )r#   r   r   x_ax_by_ay_br   s           r   gcdexzGaussianIntegerRing.gcdex  s    hiih 	*QAa!a%iqAC!c'MCC!c'MC	  	* nnQS113C{r   c                :    ||z  |                      ||          z  S )z+Least common multiple of a and b over ZZ_I.)r   r   s      r   lcmzGaussianIntegerRing.lcm  s    A$((1a..((r   c                    |S )zConvert a ZZ_I element to ZZ_I.r1   r   s      r   from_GaussianIntegerRingz,GaussianIntegerRing.from_GaussianIntegerRing      r   c                    |                      t          j        |j                  t          j        |j                            S )zConvert a QQ_I element to ZZ_I.)r   r   r   r   r   r   s      r   from_GaussianRationalFieldz.GaussianIntegerRing.from_GaussianRationalField  s*    vvbjoorz!#777r   N) rr   rs   rt   ru   r   r   r   rO   r   modr}   dtype	imag_unitr   r9   is_GaussianRingis_ZZ_Iis_PIDr   r-   r'   propertyr   r   r   r   r   r   r   r   r   r   r1   r   r   r   r   H  s       b bF C
#rvrw'
,
,CE5A1D
%1rr!uu

CbbeeRRUU##I)cTI:.E
COGF% % %" " "     X      * * *! ! !  ) ) )  8 8 8 8 8r   r   c                     e Zd ZdZeZ eej        ej        ej        ge          Z	e
Z e ed           ed                    Z e ed           ed                    Z e ed           ed                    Zeee e fZdZdZdZd Zd Zd Zed	             Zd
 Zd Zd Zd Zd Zd Zd Zd Zd ZdS )GaussianRationalFielda  Field of Gaussian rationals ``QQ_I``

    The :ref:`QQ_I` domain represents the `Gaussian rationals`_ `\mathbb{Q}(i)`
    as a :py:class:`~.Domain` in the domain system (see
    :ref:`polys-domainsintro`).

    By default a :py:class:`~.Poly` created from an expression with
    coefficients that are combinations of rationals and ``I`` (`\sqrt{-1}`)
    will have the domain :ref:`QQ_I`.

    >>> from sympy import Poly, Symbol, I
    >>> x = Symbol('x')
    >>> p = Poly(x**2 + I/2)
    >>> p
    Poly(x**2 + I/2, x, domain='QQ_I')
    >>> p.domain
    QQ_I

    The polys option ``gaussian=True`` can be used to specify that the domain
    should be :ref:`QQ_I` even if the coefficients do not contain ``I`` or are
    all integers.

    >>> Poly(x**2)
    Poly(x**2, x, domain='ZZ')
    >>> Poly(x**2 + I)
    Poly(x**2 + I, x, domain='ZZ_I')
    >>> Poly(x**2/2)
    Poly(1/2*x**2, x, domain='QQ')
    >>> Poly(x**2, gaussian=True)
    Poly(x**2, x, domain='QQ_I')
    >>> Poly(x**2 + I, gaussian=True)
    Poly(x**2 + I, x, domain='QQ_I')
    >>> Poly(x**2/2, gaussian=True)
    Poly(1/2*x**2, x, domain='QQ_I')

    The :ref:`QQ_I` domain can be used to factorise polynomials that are
    reducible over the Gaussian rationals.

    >>> from sympy import factor, QQ_I
    >>> factor(x**2/4 + 1)
    (x**2 + 4)/4
    >>> factor(x**2/4 + 1, domain='QQ_I')
    (x - 2*I)*(x + 2*I)/4
    >>> factor(x**2/4 + 1, domain=QQ_I)
    (x - 2*I)*(x + 2*I)/4

    It is also possible to specify the :ref:`QQ_I` domain explicitly with
    polys functions like :py:func:`~.apart`.

    >>> from sympy import apart
    >>> apart(1/(1 + x**2))
    1/(x**2 + 1)
    >>> apart(1/(1 + x**2), domain=QQ_I)
    I/(2*(x + I)) - I/(2*(x - I))

    The corresponding `ring of integers`_ is the domain of the Gaussian
    integers :ref:`ZZ_I`. Conversely :ref:`QQ_I` is the `field of fractions`_
    of :ref:`ZZ_I`.

    >>> from sympy import ZZ_I, QQ_I, QQ
    >>> ZZ_I.get_field()
    QQ_I
    >>> QQ_I.get_ring()
    ZZ_I

    When using the domain directly :ref:`QQ_I` can be used as a constructor.

    >>> QQ_I(3, 4)
    (3 + 4*I)
    >>> QQ_I(5)
    (5 + 0*I)
    >>> QQ_I(QQ(2, 3), QQ(4, 5))
    (2/3 + 4/5*I)

    The domain elements of :ref:`QQ_I` are instances of
    :py:class:`~.GaussianRational` which support the field operations
    ``+,-,*,**,/``.

    >>> z1 = QQ_I(5, 1)
    >>> z2 = QQ_I(2, QQ(1, 2))
    >>> z1
    (5 + 1*I)
    >>> z2
    (2 + 1/2*I)
    >>> z1 + z2
    (7 + 3/2*I)
    >>> z1 * z2
    (19/2 + 9/2*I)
    >>> z2 ** 2
    (15/4 + 2*I)

    True division (``/``) in :ref:`QQ_I` gives an element of :ref:`QQ_I` and
    is always exact.

    >>> z1 / z2
    (42/17 + -2/17*I)
    >>> QQ_I.exquo(z1, z2)
    (42/17 + -2/17*I)
    >>> z1 == (z1/z2)*z2
    True

    Both floor (``//``) and modulo (``%``) division can be used with
    :py:class:`~.GaussianRational` (see :py:meth:`~.Domain.div`)
    but division is always exact so there is no remainder.

    >>> z1 // z2
    (42/17 + -2/17*I)
    >>> z1 % z2
    (0 + 0*I)
    >>> QQ_I.div(z1, z2)
    ((42/17 + -2/17*I), (0 + 0*I))
    >>> (z1//z2)*z2 + z1%z2 == z1
    True

    .. _Gaussian rationals: https://en.wikipedia.org/wiki/Gaussian_rational
    r   rM   r_   Tc                    dS )zFor constructing QQ_I.Nr1   r"   s    r   r   zGaussianRationalField.__init__  r   r   c                >    t          |t                    rdS t          S r   )r)   r   r*   r+   s     r   r-   zGaussianRationalField.__eq__  s     e233 	"4!!r   c                     t          d          S )r   r_   r   r"   s    r   r'   zGaussianRationalField.__hash__  r   r   c                    dS r   r1   r"   s    r   r   z,GaussianRationalField.has_CharacteristicZero  r   r   c                    dS rc   r1   r"   s    r   r   z$GaussianRationalField.characteristic  r   r   c                    t           S r   )r   r"   s    r   r   zGaussianRationalField.get_ring  r   r   c                    | S r   r1   r"   s    r   r   zGaussianRationalField.get_field  r   r   c                6    t          | j        t                    S )z0Get equivalent domain as an ``AlgebraicField``. )r	   r   r   r"   s    r   as_AlgebraicFieldz'GaussianRationalField.as_AlgebraicField  s    dh***r   c                    |                                  }|                    ||                     |          z            S )zGet the numerator of ``a``.)r   r   denom)r#   r   r   s      r   numerzGaussianRationalField.numer  s0    }}||A

1-...r   c                    | j                                         }| j         }|                                 } |j         |j        |j                   |j        |j                            } |||j                  S )zGet the denominator of ``a``.)r   r   r   r
  r   r   r   )r#   r   r   r   r   denom_ZZs         r   r
  zGaussianRationalField.denom  sh    X  X}}26("(13--!#77tHbg&&&r   c                B    |                      |j        |j                  S )zConvert a ZZ_I element to QQ_I.r4   r   s      r   r   z.GaussianRationalField.from_GaussianIntegerRing  s    vvac13r   c                    |S )zConvert a QQ_I element to QQ_I.r1   r   s      r   r   z0GaussianRationalField.from_GaussianRationalField  r   r   c                    |                      t          j        |j                  t          j        |j                            S )z'Convert a ComplexField element to QQ_I.)r   r   r   realimagr   s      r   from_ComplexFieldz'GaussianRationalField.from_ComplexField  s.    vvbj(("*QV*<*<===r   N)rr   rs   rt   ru   r   r   r   rO   r   r   r   r   r   r   r9   is_GaussianFieldis_QQ_Ir   r-   r'   r   r   r   r   r   r  r  r
  r   r   r  r1   r   r   r   r     s       s sh C
#rvrw'
,
,CE5A1D
%1rr!uu

CbbeeRRUU##I)cTI:.E
CG% % %" " "     X      + + +/ / /
' ' '       > > > > >r   r   N) ru   
__future__r   sympy.core.numbersr   sympy.polys.polyclassesr   sympy.polys.polyerrorsr   sympy.polys.domains.integerringr   !sympy.polys.domains.rationalfieldr   "sympy.polys.domains.algebraicfieldr	   sympy.polys.domains.domainr
   !sympy.polys.domains.domainelementr   sympy.polys.domains.fieldr   sympy.polys.domains.ringr   r   r}   r   r   r   r   r   r   r_   r1   r   r   <module>r!     s,     " " " " " "             ' ' ' ' ' ' 1 1 1 1 1 1 . . . . . . 0 0 0 0 0 0 = = = = = = - - - - - - ; ; ; ; ; ; + + + + + + ) ) ) ) ) )X5 X5 X5 X5 X5m X5 X5 X5v%! %! %! %! %!o %! %! %!P )  )  )  )  )  )  )  )FO1 O1 O1 O1 O1 O1 O1 O1dx8 x8 x8 x8 x8.$ x8 x8 x8t "5!4!6!6 6z> z> z> z> z>NE z> z> z>z #8"7"9"9 9r   