§
    OŠtjŽL  ã                  ó|  — 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       úa/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/polys/domains/gaussiandomains.pyÚ__new__zGaussianElement.__new__   s0   € ØŒxÔˆØ�wŠw�t�t˜A‘w”w   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-   ø€ õ ‰gŒg�oŠo˜cÑ"Ô"ˆØˆŒØˆŒØˆ
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   € Ý�T”V˜TœVÐ$Ñ%Ô%Ð%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   € Ý�e˜Tœ^Ñ,Ô,ð 	"Ø”6˜UœWÒ$Ð:¨¬°5´7Ò):Ð:å!Ð!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ð 	"Ý!Ð!Ø”˜œÐ 5¤7¨E¬GÐ"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   € Ø�xŠx˜œ˜ $¤& Ñ)Ô)Ð)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��øÝ!ð "ð "ð "Ø!�z�zð"øøøàŒ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Øˆ=Ø—8’8˜DœF Q™J¨¬°©
Ñ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Øˆ=Ø—8’8˜A ¤™J¨¨D¬F©
Ñ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Øˆ=Ø—8’8˜DœF 1™H t¤v¨a¡xÑ/°´¸±¸D¼FÀ1¹HÑ1DÑ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¨   € Ø�!Š8ˆ8Ø—8’8˜A˜q‘>”>Ð!Ø�Š7ˆ7Ø˜$™  �#ˆDØ�!Š8ˆ8ØˆKØˆØ˜Q‘wÐ4ˆtˆt D¤LÔ$4ˆØ�‰	ˆØð 	Ø�D‰LˆDØ�Q‰wð Ø˜‘�Ø�A‰IˆCð	 ð 	ð
 ˆr   c                óR   — t          | j        ¦  «        pt          | j        ¦  «        S r   )Úboolr   r   r"   s    r   Ú__bool__zGaussianElement.__bool__{   s   € Ý�D”F‰|Œ|Ð+�t D¤F™|œ|Ð+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   € ð
 Œ6�AŠ:ˆ:Øœ š
˜
�1�1¨Ð)ØŒV�aŠZˆZØœ š
˜
�1�1¨Ð)àœ !š˜�1�1¨Ð*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   € ð	+Ý—L’L Ñ'Ô'ˆEð ×$Ò$ TÑ*Ô*Ð*øõ ð 	"ð 	"ð 	"Ý!Ð!Ð!Ð!ð	"øøør]   c                óR   — |                       |¦  «        }|t          u r|n|d         S ©Nr   ©r[   r*   ©r#   r,   Úqrs      r   Ú__floordiv__zGaussianElement.__floordiv__š   ó+   € Ø�_Š_˜UÑ#Ô#ˆØ�>Ð)Ð)ˆrˆr¨r°!¬uÐ4r   c                óR   — |                       |¦  «        }|t          u r|n|d         S rc   ©r\   r*   re   s      r   Ú__rfloordiv__zGaussianElement.__rfloordiv__ž   ó-   € Ø×Ò˜eÑ$Ô$ˆØ�>Ð)Ð)ˆrˆr¨r°!¬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Þ  ø€ € € € € € Ø;Ð;Ø€L€L�LØ€O€O�Oà€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 )ÚGaussianIntegerzîGaussian 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Ý!Ð!ð Œv�a‰x˜$œ& ™(Ñ" T¤V G¨A¡I°´°q±Ñ$8ˆ1ˆØˆa‰C�!�A‘#‰Iˆð �‰c�A‰g˜1˜Q™3ÑˆØ�‰c�A‰g˜1˜Q™3Ñˆå˜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š   € àð 	;Ý# H§O¢O°DÑ$9Ô$9Ñ:Ô:Ð:Ø�|Š|˜EÑ"Ô"‰ˆˆ1Øˆ9Ý!Ð!Øˆa‰C�!�A‘#‰Iˆå ¤¨¡¨D¬F°1©HÑ!4°aÑ 7Ø"&¤& ¨¡¨T¬V°A©XÑ!5°qÑ 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×(Ò(¨Ñ/Ô/ˆEˆEøÝð 	"ð 	"ð 	"Ý!Ð!Ð!Ð!ð	"øøøàð 	)Ý# H§O¢O°DÑ$9Ô$9Ñ:Ô:Ð:à˜‘:�tœyÐ(Ð(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Ô ˆØˆt�A”C‰yŒy�1˜T˜T !¤#™YœY™;Ñ&Ð&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×Ò Ñ"Ô"ˆØð 	"Ø—8’8˜A˜q‘>”>Ð!Ø�~Š~ÑÔ‰ˆˆ1ØŒH×Ò Ñ"Ô"ˆØ•ˆ6ˆ6Ø—8’8˜A˜q‘>”>Ð!å Ð!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   € ØŒz˜1Ÿ:š:™<œ<˜-Ô(ˆØˆ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�!‰uŒuˆ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  € € € € € € Ø*Ð*Ø€K€K�Kà€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 )z€Return 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'   øè è € Ð*Ð* �Q�t‘VÐ*Ð*Ð*Ð*Ð*Ð*r   )rŸ   Útuple)r#   r�   rÀ   rž   s      @r   Ú	normalizezGaussianIntegerRing.normalize×  sX   ø€ ð
 ×"Ò" 1Ñ%Ô%ˆØ	ˆT‰	ˆÝÐ*Ð*Ð*Ð* TÐ*Ñ*Ô*Ñ*Ô*ˆØ"Ð)�ˆt�d‰{ˆ{¨Ð)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˜!‘eˆqˆAð ð 	à�~Š~˜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™%‘iˆqˆAØ˜C ! c¡'™M�ˆCØ˜C ! c¡'™M�ˆCð	 ð 	*ð —n’n Q¨¨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‘˜$Ÿ(š( 1 a™.œ.Ñ(Ð(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*   € à�vŠv•b”j ¤‘o”o¥r¤z°!´#¡¤Ñ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Ø
ˆ#ˆrŒv�r”w ¤Ð'¨Ñ
,Ô
,€CØ€EØˆ5���A‘”˜˜˜1™œÑÔ€DØ
ˆ%���1‘”�r�r˜!‘u”uÑ
Ô
€CØ��b�b˜‘e”e˜R˜R ™UœUÑ#Ô#€IØ�)˜c˜T I :Ð.€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   € å˜dœh­Ñ*Ô*Ð*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ˆØ�}Š}‰ŒˆØ�2”6˜(˜"œ( 1¤3™-œ-¨¨¬°!´#©¬Ñ7Ô7ˆØˆt�H˜bœgÑ&Ô&Ð&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   € à�vŠv�a”c˜1œ3ÑÔÐ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.   € à�vŠv•b”j ¤Ñ(Ô(­"¬*°Q´VÑ*<Ô*<Ñ=Ô=Ð=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Ø
ˆ#ˆrŒv�r”w ¤Ð'¨Ñ
,Ô
,€CØ€EØˆ5���A‘”˜˜˜1™œÑÔ€DØ
ˆ%���1‘”�r�r˜!‘u”uÑ
Ô
€CØ��b�b˜‘e”e˜R˜R ™UœUÑ#Ô#€IØ�)˜c˜T I :Ð.€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5�mñ X5ô X5ð X5ðv%!ð %!ð %!ð %!ð %!�oñ %!ô %!ð %!ðP )ð  )ð  )ð  )ð  )�ñ  )ô  )ð  )ðFO1ð O1ð O1ð O1ð O1ñ O1ô O1ð O1ðdx8ð x8ð x8ð x8ð x8˜.¨$ñ x8ô x8ð x8ðt "5Ð!4Ñ!6Ô!6Ð 6€€Ôðz>ð z>ð z>ð z>ð z>˜N¨Eñ z>ô z>ð z>ðz #8Ð"7Ñ"9Ô"9Ð 9€ÐÔÐÐr   