EdUFddZddlmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZGd d eZGd deZGddeZGddZGddeeZexZe_GddeeZexZe_dS)zDomains of Gaussian type.)I)CoercionFailed)ZZ)QQ)AlgebraicField)Domain) DomainElement)Field)RingceZdZdZdZdZdZddZefdZ dZ dZ d Z d Z d Zd Zd ZdZedZdZeZdZdZdZeZdZdZdZdZdZdZdZdZ dZ!xZ"S)GaussianElementz1Base class for elements of Gaussian type domains.N)xyrcj|jj}|||||SN)baseconvertnew)clsrrconvs Clib/python3.11/site-packages/sympy/polys/domains/gaussiandomains.py__new__zGaussianElement.__new__s0xwwttAwwQ(((cft|}||_||_|S)z0Create a new GaussianElement of the same domain.)superrrr)rrrobj __class__s rrzGaussianElement.news-ggooc"" rc|jS)z4The domain that this is an element of (ZZ_I or QQ_I))_parentselfs rparentzGaussianElement.parent!s |rc8t|j|jfSr)hashrrr s r__hash__zGaussianElement.__hash__%sTVTV$%%%rczt||jr |j|jko|j|jkStSr) isinstancerrrNotImplementedr!others r__eq__zGaussianElement.__eq__(s9 eT^ , , "6UW$:57): :! !rcvt|tstS|j|jg|j|jgkSr)r'r r(rrr)s r__lt__zGaussianElement.__lt__.s7%11 "! !57EG"444rc|Srr s r__pos__zGaussianElement.__pos__3s rcF||j |j Srrrrr s r__neg__zGaussianElement.__neg__6sxx$&)))rc@|jjd|jd|jdS)N(z, ))rreprrr s r__repr__zGaussianElement.__repr__9s&#|///@@rcPt|j|Sr)strrto_sympyr s r__str__zGaussianElement.__str__<s 4<((..///rct||s- |j|}n#t$rYdSwxYw|j|jfS)N)NN)r'rrrrr)rr*s r_get_xyzGaussianElement._get_xy?sa%%% " " ++E22! " " "!zz "ws - ;;c||\}}|&||j|z|j|zStSrr>rrrr(r!r*rrs r__add__zGaussianElement.__add__HE||E""1  "88DFQJ 33 3! !rc||\}}|&||j|z |j|z StSrr@rAs r__sub__zGaussianElement.__sub__QrCrc||\}}|&|||jz ||jz StSrr@rAs r__rsub__zGaussianElement.__rsub__XsE||E""1  "88AJDF 33 3! !rc||\}}|<||j|z|j|zz |j|z|j|zzStSrr@rAs r__mul__zGaussianElement.__mul___s[||E""1  "88DF1Htvax/DF1H1DEE E! !rc|dkr|ddS|dkrd|z | }}|dkr|S|}|dzr|n |jj}|dz}|r||z}|dzr||z}|dz}||S)Nr)rrone)r!exppow2prods r__pow__zGaussianElement.__pow__hs !8 "88Aq>> ! 7 %$#D !8 KQw4ttDL$4    DLDQw   AIC    rcRt|jpt|jSr)boolrrr s r__bool__zGaussianElement.__bool__ysDF||+tDF||+rc|jdkr|jdkrdndS|jdkr|jdkrdndS|jdkrdndS)zIReturn quadrant index 0-3. 0 is included in quadrant 0. rrKrL)rrr s rquadrantzGaussianElement.quadrant|s_ 6A: + )11 ) VaZ + )11 )! *11 *rc |j|}||S#t$r tcYSwxYwr)rr __divmod__rr(r)s r __rdivmod__zGaussianElement.__rdivmod__s[ *L((//E##D)) ) " " "! ! ! ! "1AAc t|}||S#t$r tcYSwxYwr)QQ_Ir __truediv__rr(r)s r __rtruediv__zGaussianElement.__rtruediv__sW +LL''E$$T** * " " "! ! ! ! "r[cR||}|tur|n|dSNrrYr(r!r*qrs r __floordiv__zGaussianElement.__floordiv__+ __U # #>)4rrr!u4rcR||}|tur|n|dSrarZr(rcs r __rfloordiv__zGaussianElement.__rfloordiv__-   e $ $>)4rrr!u4rcR||}|tur|n|dSNrKrbrcs r__mod__zGaussianElement.__mod__rfrcR||}|tur|n|dSrlrhrcs r__rmod__zGaussianElement.__rmod__rjr)r)#__name__ __module__ __qualname____doc__rr __slots__r classmethodrr"r%r+r-r0r3r8r<r>rB__radd__rErGrI__rmul__rQrTrWrZr_rerirmro __classcell__)rs@rr r s;; DGI))))[&&&""" 555 ***AAA000  [ """H"""""""""H",,, + + +***+++5555555555555555rr c"eZdZdZeZdZdZdS)GaussianIntegerzGaussian integer: domain element for :ref:`ZZ_I` >>> from sympy import ZZ_I >>> z = ZZ_I(2, 3) >>> z (2 + 3*I) >>> type(z) c<t||z S)Return a Gaussian rational.)r]rr)s rr^zGaussianInteger.__truediv__s||D!!%''rcd|s"td|||\}}|tS|j|z|j|zz|j |z|j|zz}}||z||zz}d|z|zd|zz}d|z|zd|zz}t ||} | || |zz fS)Nz divmod({}, 0)rL)ZeroDivisionErrorformatr>r(rrrz) r!r*rrabcqxqyqs rrYzGaussianInteger.__divmod__s B#O$:$:4$@$@AA A||E""1  "! !vax$&("TVGAIq$81 aC!A#IcAg1Q3 cAg1Q3  B # #$5.  rN)rprqrrrsrrr^rYr/rrrzrzsC D(((!!!!!rrzc"eZdZdZeZdZdZdS)GaussianRationalaGaussian 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) c|s"td|||\}}|tS||z||zz}t |j|z|j|zz|z |j |z|j|zz|z S)r|z{} / 0)r~rr>r(rrr)r!r*rrrs rr^zGaussianRational.__truediv__s ;#HOOD$9$9:: :||E""1  "! ! aC!A#IDF1H!4a 7"&&TVAX!5q 8:: :rc |j|}n#t$r tcYSwxYw|s"t d|||z t jfS)Nz{} % 0)rrrr(r~rr]zeror)s rrYzGaussianRational.__divmod__sx "L((//EE " " "! ! ! ! " )#HOOD$9$9:: ::ty( (s 11N)rprqrrrsrrr^rYr/rrrrsC D : : :)))))rrceZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ d Zd Zd Zd Zd ZdZdZdZdZdZdS)GaussianDomainz Base class for Gaussian domains.NTcl|jj}||jt||jzzS)z!Convert ``a`` to a SymPy object. )domr;rrr)r!rrs rr;zGaussianDomain.to_sympys/x tACyy1TT!#YY;&&rcx|\}}|j|}|s||dS|\}}|j|}|t ur|||St d|)z)Convert a SymPy object to ``self.dtype``.rz{} is not Gaussian) as_coeff_Addr from_sympyr as_coeff_Mulrrr)r!rrrrrs rrzGaussianDomain.from_sympys~~1 H   " " "88Aq>> !~~1 H   " " 6 A88Aq>> ! !5! or QQ to ``self.dtype``.rN)extargsrrr;rs rfrom_AlgebraicFieldz"GaussianDomain.from_AlgebraicField@s= 6;q>Q  1==Q00 0 1 1r)rprqrrrsr is_Numericalis_Exacthas_assoc_Ringhas_assoc_Fieldr;rrrrrrrrrrrrrrr/rrrrs** CLHNO''' A A A%%%11111rrceZdZdZeZeZeededZeededZ eededZ e e e e fZ dZ dZ dZdZdZdZd Zd Zd Zd Zd ZdS)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 rrKZZ_ITcdS)zFor constructing ZZ_I.Nr/r s r__init__zGaussianIntegerRing.__init__rc|Sz)Returns a ring associated with ``self``. r/r s rget_ringzGaussianIntegerRing.get_ring rctSz*Returns a field associated with ``self``. )r]r s r get_fieldzGaussianIntegerRing.get_field rc|||z}tfd|D}|r|f|zn|S)zReturn first quadrant element associated with ``d``. Also multiply the other arguments by the same power of i. c3"K|] }|zV dSrr/).0rrs r z0GaussianIntegerRing.normalize..s'**QtV******r)rtuple)r!rrrs @r normalizezGaussianIntegerRing.normalizesX ""1%% T ****T*****")td{{)rcB|r |||z}}| ||S)z-Greatest common divisor of a and b over ZZ_I.)rr!rrs rgcdzGaussianIntegerRing.gcds3 a!eqA ~~a   rc:||z|||zS)z+Least common multiple of a and b over ZZ_I.)rrs rlcmzGaussianIntegerRing.lcmsA$((1a..((rc|S)zConvert a ZZ_I element to ZZ_I.r/rs rfrom_GaussianIntegerRingz,GaussianIntegerRing.from_GaussianIntegerRingrc|tj|jtj|jS)zConvert a QQ_I element to ZZ_I.)rrrrrrs rfrom_GaussianRationalFieldz.GaussianIntegerRing.from_GaussianRationalFields*vvbjoorz!#777rN)rprqrrrsrrrzdtyperrM imag_unitrr7is_GaussianRingis_ZZ_Irrrrrrrrr/rrrrFs)bbF C E 5A1  D %1rr!uu  CbbeeRRUU##I )cTI: .E COG%%%***!!! )))88888rrceZdZdZeZeZeededZeededZ eededZ e e e e fZ dZ dZ dZdZdZdZd Zd Zd Zd Zd ZdS)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 rrKr]TcdS)zFor constructing QQ_I.Nr/r s rrzGaussianRationalField.__init__arrctSr)rr s rrzGaussianRationalField.get_ringdrrc|Srr/r s rrzGaussianRationalField.get_fieldhrrc6t|jtS)z0Get equivalent domain as an ``AlgebraicField``. )rrrr s ras_AlgebraicFieldz'GaussianRationalField.as_AlgebraicFieldlsdh***rc|}||||zS)zGet the numerator of ``a``.)rrdenom)r!rrs rnumerzGaussianRationalField.numerps0}}||A 1 -...rc|j}|j}|}|j|j|j|j|j}|||jS)zGet the denominator of ``a``.)rrrrrrr)r!rrrrdenom_ZZs rrzGaussianRationalField.denomush X    X}}26("(13--!#77tHbg&&&rcB||j|jS)zConvert a ZZ_I element to QQ_I.r2rs rrz.GaussianRationalField.from_GaussianIntegerRing}svvac13rc|S)zConvert a QQ_I element to QQ_I.r/rs rrz0GaussianRationalField.from_GaussianRationalFieldrrN)rprqrrrsrrrrrrMrrr7is_GaussianFieldis_QQ_Irrrrrrrrr/rrrrs*ssh C E 5A1  D %1rr!uu  CbbeeRRUU##I )cTI: .E CG%%%+++/// '''   rrN)rssympy.core.numbersrsympy.polys.polyerrorsrsympy.polys.domains.integerringr!sympy.polys.domains.rationalfieldr"sympy.polys.domains.algebraicfieldrsympy.polys.domains.domainr!sympy.polys.domains.domainelementr sympy.polys.domains.fieldr sympy.polys.domains.ringr r rzrrrrrrr]r/rrrs 111111......000000======------;;;;;;++++++))))))X5X5X5X5X5mX5X5X5v%!%!%!%!%!o%!%!%!P ) ) ) ) ) ) ) )FO1O1O1O1O1O1O1O1dU8U8U8U8U8.$U8U8U8n"5!4!6!66cccccNEcccJ#8"7"9"99r