U Zʹj=J@sdZddlmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZGd d d eZGd ddeZGdddeZGdddZGdddeeZeZe_GdddeeZeZe_dS)zDomains of Gaussian type.)I)CoercionFailed)ZZ)QQ)AlgebraicField)Domain) DomainElement)Field)RingcseZdZUdZeed<eed<dZd6ddZefdd Z d d Z d d Z ddZ ddZ ddZddZddZddZeddZddZeZddZd d!Zd"d#ZeZd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Z d4d5Z!Z"S)7GaussianElementz1Base class for elements of Gaussian type domains.base_parent)xyrcCs|jj}|||||SN)r convertnew)clsrrconvrb/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/polys/domains/gaussiandomains.py__new__szGaussianElement.__new__cst|}||_||_|S)z0Create a new GaussianElement of the same domain.)superrrr)rrrobj __class__rrrs zGaussianElement.newcCs|jS)z4The domain that this is an element of (ZZ_I or QQ_I))r selfrrrparent!szGaussianElement.parentcCst|j|jfSr)hashrrrrrr__hash__%szGaussianElement.__hash__cCs,t||jr$|j|jko"|j|jkStSdSr) isinstancerrrNotImplementedrotherrrr__eq__(s zGaussianElement.__eq__cCs&t|tstS|j|jg|j|jgkSr)r!r r"rrr#rrr__lt__.s zGaussianElement.__lt__cCs|Srrrrrr__pos__3szGaussianElement.__pos__cCs||j |j Srrrrrrrr__neg__6szGaussianElement.__neg__cCsd|jj|j|jfS)Nz %s(%s, %s))r reprrrrrr__repr__9szGaussianElement.__repr__cCst|j|Sr)strr to_sympyrrrr__str__<szGaussianElement.__str__cCs>t||s2z|j|}Wntk r0YdSX|j|jfS)N)NN)r!r rrrr)rr$rrr_get_xy?s  zGaussianElement._get_xycCs6||\}}|dk r.||j||j|StSdSrr/rrrr"rr$rrrrr__add__HszGaussianElement.__add__cCs6||\}}|dk r.||j||j|StSdSrr0r1rrr__sub__QszGaussianElement.__sub__cCs6||\}}|dk r.|||j||jStSdSrr0r1rrr__rsub__XszGaussianElement.__rsub__cCsJ||\}}|dk rB||j||j||j||j|StSdSrr0r1rrr__mul___s,zGaussianElement.__mul__cCs|dkr|ddS|dkr,d|| }}|dkr8|S|}|drH|n|jj}|d}|r~||9}|drt||9}|d}qX|S)Nr)rr one)rexpZpow2prodrrr__pow__hs  zGaussianElement.__pow__cCst|jpt|jSr)boolrrrrrr__bool__yszGaussianElement.__bool__cCsN|jdkr|jdkrdSdS|jdkr8|jdkr4dSdS|jdkrFdSdSdS)zIReturn quadrant index 0-3. 0 is included in quadrant 0. rr6r7N)rrrrrrquadrant|s   zGaussianElement.quadrantcCs8z|j|}Wntk r(tYSX||SdSr)r rrr" __divmod__r#rrr __rdivmod__s  zGaussianElement.__rdivmod__cCs6zt|}Wntk r&tYSX||SdSr)QQ_Irrr" __truediv__r#rrr __rtruediv__s  zGaussianElement.__rtruediv__cCs||}|tkr|S|dSNrr@r"rr$Zqrrrr __floordiv__s zGaussianElement.__floordiv__cCs||}|tkr|S|dSrErAr"rGrrr __rfloordiv__s zGaussianElement.__rfloordiv__cCs||}|tkr|S|dSNr6rFrGrrr__mod__s zGaussianElement.__mod__cCs||}|tkr|S|dSrKrIrGrrr__rmod__s zGaussianElement.__rmod__)r)#__name__ __module__ __qualname____doc__r__annotations__ __slots__r classmethodrrr r%r&r'r)r+r.r/r2__radd__r3r4r5__rmul__r;r=r?rArDrHrJrLrM __classcell__rrrrr s@    r c@s$eZdZdZeZddZddZdS)GaussianIntegerzGaussian integer: domain element for :ref:`ZZ_I` >>> from sympy import ZZ_I >>> z = ZZ_I(2, 3) >>> z (2 + 3*I) >>> type(z) cCst||S)Return a Gaussian rational.)rBrr#rrrrCszGaussianInteger.__truediv__c Cs|std|||\}}|dkr,tS|j||j||j ||j|}}||||}d||d|}d||d|}t||} | || |fS)Nz divmod({}, 0)r7)ZeroDivisionErrorformatr/r"rrrX) rr$rrabcZqxZqyqrrrr@s, zGaussianInteger.__divmod__N)rNrOrPrQrr rCr@rrrrrXs rXc@s$eZdZdZeZddZddZdS)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) cCsp|std|||\}}|dkr,tS||||}t|j||j|||j ||j||S)rYz{} / 0N)rZr[r/r"r`rr)rr$rrr^rrrrCszGaussianRational.__truediv__cCsPz|j|}Wntk r(tYSX|s>td|n||tjfSdS)Nz{} % 0)r rrr"rZr[rBzeror#rrrr@s zGaussianRational.__divmod__N)rNrOrPrQrr rCr@rrrrr`s  r`c@seZdZdZdZdZdZdZdZddZ ddZ dd Z d d Z d d Z ddZddZddZddZddZddZddZddZddZd d!ZdS)"GaussianDomainz Base class for Gaussian domains.NTcCs |jj}||jt||jS)z!Convert ``a`` to a SymPy object. )domr-rrr)rr\rrrrr-szGaussianDomain.to_sympycCsf|\}}|j|}|s(||dS|\}}|j|}|tkrT|||Std|dS)z)Convert a SymPy object to ``self.dtype``.rz{} is not GaussianN)Z as_coeff_Addrc from_sympyrZ as_coeff_Mulrrr[)rr\rr]rrrrrrds      zGaussianDomain.from_sympycGs |j|S)z$Inject generators into this domain. )Z poly_ring)rZgensrrrinjectszGaussianDomain.injectcCs|j| }|Sr)unitsr?)rdunitrrrcanonical_unitszGaussianDomain.canonical_unitcCsdSz/Returns ``False`` for any ``GaussianElement``. Frrelementrrr is_negativeszGaussianDomain.is_negativecCsdSrkrrlrrr is_positiveszGaussianDomain.is_positivecCsdSrkrrlrrris_nonnegative szGaussianDomain.is_nonnegativecCsdSrkrrlrrris_nonpositive$szGaussianDomain.is_nonpositivecCs||S)z%Convert a GMPY mpz to ``self.dtype``.rZK1r\ZK0rrr from_ZZ_gmpy(szGaussianDomain.from_ZZ_gmpycCs||Sz.Convert a ZZ_python element to ``self.dtype``.rrrrrrfrom_ZZ,szGaussianDomain.from_ZZcCs||Srtrrrrrrfrom_ZZ_python0szGaussianDomain.from_ZZ_pythoncCs||Sz%Convert a GMPY mpq to ``self.dtype``.rrrrrrfrom_QQ4szGaussianDomain.from_QQcCs||Srwrrrrrr from_QQ_gmpy8szGaussianDomain.from_QQ_gmpycCs||S)z.Convert a QQ_python element to ``self.dtype``.rrrrrrfrom_QQ_python<szGaussianDomain.from_QQ_pythoncCs$|jjdtkr |||SdS)z9Convert an element from ZZ or QQ to ``self.dtype``.rN)extargsrrdr-rrrrrfrom_AlgebraicField@sz"GaussianDomain.from_AlgebraicField)rNrOrPrQrcZ is_NumericalZis_ExactZhas_assoc_RingZhas_assoc_Fieldr-rdrfrjrnrorprqrsrurvrxryrzr}rrrrrbs* rbc@seZdZdZeZeZeededZeededZ eededZ e e e e fZ dZ dZ dZddZdd Zd d Zed d ZddZddZddZddZddZddZddZddZdS)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 rr6ZZ_ITcCsdS)zFor constructing ZZ_I.Nrrrrr__init__szGaussianIntegerRing.__init__cCst|trdStSdSz0Returns ``True`` if two domains are equivalent. TN)r!r~r"r#rrrr%s zGaussianIntegerRing.__eq__cCstdS)Compute hash code of ``self``. rrrrrrr szGaussianIntegerRing.__hash__cCsdSNTrrrrrhas_CharacteristicZerosz*GaussianIntegerRing.has_CharacteristicZerocCsdSrErrrrrcharacteristicsz"GaussianIntegerRing.characteristiccCs|Sz)Returns a ring associated with ``self``. rrrrrget_ringszGaussianIntegerRing.get_ringcCstSz*Returns a field associated with ``self``. )rBrrrr get_fieldszGaussianIntegerRing.get_fieldcs:|||9}tfdd|D}|r6|f|S|S)zReturn first quadrant element associated with ``d``. Also multiply the other arguments by the same power of i. c3s|]}|VqdSrr).0r\rirr sz0GaussianIntegerRing.normalize..)rjtuple)rrhr|rrr normalizes zGaussianIntegerRing.normalizecCs|r|||}}q||S)z-Greatest common divisor of a and b over ZZ_I.)rrr\r]rrrgcdszGaussianIntegerRing.gcdcCs|||||S)z+Least common multiple of a and b over ZZ_I.)rrrrrlcmszGaussianIntegerRing.lcmcCs|S)zConvert a ZZ_I element to ZZ_I.rrrrrrfrom_GaussianIntegerRingsz,GaussianIntegerRing.from_GaussianIntegerRingcCs|t|jt|jS)zConvert a QQ_I element to ZZ_I.)rrrrrrrrrrfrom_GaussianRationalFieldsz.GaussianIntegerRing.from_GaussianRationalFieldN)rNrOrPrQrrcrXdtyperar8 imag_unitrgr*Zis_GaussianRingZis_ZZ_Irr%r propertyrrrrrrrrrrrrrr~Fs.c  r~c@seZdZdZeZeZeededZeededZ eededZ e e e e fZ dZ dZ dZddZdd Zd d Zed d ZddZddZddZddZddZddZddZddZddZd 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 rr6rBTcCsdS)zFor constructing QQ_I.NrrrrrrsszGaussianRationalField.__init__cCst|trdStSdSr)r!rr"r#rrrr%vs zGaussianRationalField.__eq__cCstdS)rrBrrrrrr }szGaussianRationalField.__hash__cCsdSrrrrrrrsz,GaussianRationalField.has_CharacteristicZerocCsdSrErrrrrrsz$GaussianRationalField.characteristiccCstSr)rrrrrrszGaussianRationalField.get_ringcCs|SrrrrrrrszGaussianRationalField.get_fieldcCs t|jtS)z0Get equivalent domain as an ``AlgebraicField``. )rrcrrrrras_AlgebraicFieldsz'GaussianRationalField.as_AlgebraicFieldcCs|}||||S)zGet the numerator of ``a``.)rrdenom)rr\rrrrnumerszGaussianRationalField.numercCs@|j}|j}|}|||j||j}|||jS)zGet the denominator of ``a``.)rcrrrrrra)rr\rrrZdenom_ZZrrrrs  zGaussianRationalField.denomcCs||j|jS)zConvert a ZZ_I element to QQ_I.r(rrrrrrsz.GaussianRationalField.from_GaussianIntegerRingcCs|S)zConvert a QQ_I element to QQ_I.rrrrrrrsz0GaussianRationalField.from_GaussianRationalFieldcCs|t|jt|jS)z'Convert a ComplexField element to QQ_I.)rrrrealimagrrrrrfrom_ComplexFieldsz'GaussianRationalField.from_ComplexFieldN)rNrOrPrQrrcr`rrar8rrgr*Zis_GaussianFieldZis_QQ_Irr%r rrrrrrrrrrrrrrrrs0t rN)rQZsympy.core.numbersrZsympy.polys.polyerrorsrZsympy.polys.domains.integerringrZ!sympy.polys.domains.rationalfieldrZ"sympy.polys.domains.algebraicfieldrZsympy.polys.domains.domainrZ!sympy.polys.domains.domainelementrZsympy.polys.domains.fieldr Zsympy.polys.domains.ringr r rXr`rbr~rr rrBrrrrs(         (#R* =