+ iRt^RIHt^RIHt^RIHt^RIHtH t ^RI H t ^RI H t ^RIHt^RIHt^R IHtHtHt^R IHtHt^R IHt^R IHt]!R R44tR.tR#)z)Implementation of :class:`Domain` class. ) annotations)Any)AlgebraicNumber)Basicsympify)ordered) GROUND_TYPES) DomainElement)lex)UnificationFailedCoercionFailed DomainError) _unify_gens _not_a_coeff)public) is_sequencecF]tRt^t$RtRtR]R&RtR]R&RtR]R&Rt Rt Rt Rt R;t tR;ttR;ttR;ttR;ttR;ttR;ttR;ttR;ttR;tt R;t!t"R;t#t$Rt%R t&Rt'Rt(Rt)Rt*Rt+Rt,R ]R &Rt-R ]R &R t.Rt/Rt0Rt1Rt2]3R4t4Rt5Rt6Rt7RfRlt8Rt9Rt:Rt;RtRt?Rt@RtAR tBR!tCR"tDR#tER$tFR%tGR&tHR'tIR(tJR)tKR*tLR+tMR,tNR-tOR.tPRfR/ltQR0tRR1tSR2tTR3tUR4tVR5tWR6tXR7]Y/R8ltZR7]Y/R9lt[R:t\R;t]R R/R<lt^RgR=lt_RhR>lt`R?taR@tbRAtcRBtdRCteRDtfREtgRFthRGtiRHtjRItkRJtlRKtmRLtnRMtoRNtpROtqRPtrRQtsRRttRStuRTtvRUtwRVtxRWtyRXtzRYt{RZt|R[t}R\t~R]tR^tR_tRfR`lt]tRatRbtRfRcltRdtRetR#)iDomaina*Superclass for all domains in the polys domains system. See :ref:`polys-domainsintro` for an introductory explanation of the domains system. The :py:class:`~.Domain` class is an abstract base class for all of the concrete domain types. There are many different :py:class:`~.Domain` subclasses each of which has an associated ``dtype`` which is a class representing the elements of the domain. The coefficients of a :py:class:`~.Poly` are elements of a domain which must be a subclass of :py:class:`~.Domain`. Examples ======== The most common example domains are the integers :ref:`ZZ` and the rationals :ref:`QQ`. >>> from sympy import Poly, symbols, Domain >>> x, y = symbols('x, y') >>> p = Poly(x**2 + y) >>> p Poly(x**2 + y, x, y, domain='ZZ') >>> p.domain ZZ >>> isinstance(p.domain, Domain) True >>> Poly(x**2 + y/2) Poly(x**2 + 1/2*y, x, y, domain='QQ') The domains can be used directly in which case the domain object e.g. (:ref:`ZZ` or :ref:`QQ`) can be used as a constructor for elements of ``dtype``. >>> from sympy import ZZ, QQ >>> ZZ(2) 2 >>> ZZ.dtype # doctest: +SKIP >>> type(ZZ(2)) # doctest: +SKIP >>> QQ(1, 2) 1/2 >>> type(QQ(1, 2)) # doctest: +SKIP The corresponding domain elements can be used with the arithmetic operations ``+,-,*,**`` and depending on the domain some combination of ``/,//,%`` might be usable. For example in :ref:`ZZ` both ``//`` (floor division) and ``%`` (modulo division) can be used but ``/`` (true division) cannot. Since :ref:`QQ` is a :py:class:`~.Field` its elements can be used with ``/`` but ``//`` and ``%`` should not be used. Some domains have a :py:meth:`~.Domain.gcd` method. >>> ZZ(2) + ZZ(3) 5 >>> ZZ(5) // ZZ(2) 2 >>> ZZ(5) % ZZ(2) 1 >>> QQ(1, 2) / QQ(2, 3) 3/4 >>> ZZ.gcd(ZZ(4), ZZ(2)) 2 >>> QQ.gcd(QQ(2,7), QQ(5,3)) 1/21 >>> ZZ.is_Field False >>> QQ.is_Field True There are also many other domains including: 1. :ref:`GF(p)` for finite fields of prime order. 2. :ref:`RR` for real (floating point) numbers. 3. :ref:`CC` for complex (floating point) numbers. 4. :ref:`QQ(a)` for algebraic number fields. 5. :ref:`K[x]` for polynomial rings. 6. :ref:`K(x)` for rational function fields. 7. :ref:`EX` for arbitrary expressions. Each domain is represented by a domain object and also an implementation class (``dtype``) for the elements of the domain. For example the :ref:`K[x]` domains are represented by a domain object which is an instance of :py:class:`~.PolynomialRing` and the elements are always instances of :py:class:`~.PolyElement`. The implementation class represents particular types of mathematical expressions in a way that is more efficient than a normal SymPy expression which is of type :py:class:`~.Expr`. The domain methods :py:meth:`~.Domain.from_sympy` and :py:meth:`~.Domain.to_sympy` are used to convert from :py:class:`~.Expr` to a domain element and vice versa. >>> from sympy import Symbol, ZZ, Expr >>> x = Symbol('x') >>> K = ZZ[x] # polynomial ring domain >>> K ZZ[x] >>> type(K) # class of the domain >>> K.dtype # doctest: +SKIP >>> p_expr = x**2 + 1 # Expr >>> p_expr x**2 + 1 >>> type(p_expr) >>> isinstance(p_expr, Expr) True >>> p_domain = K.from_sympy(p_expr) >>> p_domain # domain element x**2 + 1 >>> type(p_domain) >>> K.to_sympy(p_domain) == p_expr True The :py:meth:`~.Domain.convert_from` method is used to convert domain elements from one domain to another. >>> from sympy import ZZ, QQ >>> ez = ZZ(2) >>> eq = QQ.convert_from(ez, ZZ) >>> type(ez) # doctest: +SKIP >>> type(eq) # doctest: +SKIP Elements from different domains should not be mixed in arithmetic or other operations: they should be converted to a common domain first. The domain method :py:meth:`~.Domain.unify` is used to find a domain that can represent all the elements of two given domains. >>> from sympy import ZZ, QQ, symbols >>> x, y = symbols('x, y') >>> ZZ.unify(QQ) QQ >>> ZZ[x].unify(QQ) QQ[x] >>> ZZ[x].unify(QQ[y]) QQ[x,y] If a domain is a :py:class:`~.Ring` then is might have an associated :py:class:`~.Field` and vice versa. The :py:meth:`~.Domain.get_field` and :py:meth:`~.Domain.get_ring` methods will find or create the associated domain. >>> from sympy import ZZ, QQ, Symbol >>> x = Symbol('x') >>> ZZ.has_assoc_Field True >>> ZZ.get_field() QQ >>> QQ.has_assoc_Ring True >>> QQ.get_ring() ZZ >>> K = QQ[x] >>> K QQ[x] >>> K.get_field() QQ(x) See also ======== DomainElement: abstract base class for domain elements construct_domain: construct a minimal domain for some expressions Nz type | NonedtyperzerooneFTz str | Nonerepaliasc \hNNotImplementedErrorselfs&z/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/sympy/polys/domains/domain.py__init__Domain.__init__gs!!c VP#r)rrs&r__str__Domain.__str__js xxr"c \V4#r)strrs&r__repr__Domain.__repr__ms 4yr"c X\VPPVP34#r)hash __class____name__rrs&r__hash__Domain.__hash__ps T^^,,djj9::r"c "VP!V!#rrrargss&*rnew Domain.newszz4  r"c VP#)z#Alias for :py:attr:`~.Domain.dtype`r1rs&rtp Domain.tpvszzr"c "VP!V!#)z7Construct an element of ``self`` domain from ``args``. )r4r2s&*r__call__Domain.__call__{sxxr"c "VP!V!#rr1r2s&*rnormal Domain.normalr6r"c  VPeRVP,pMRVPP,p\W4pVeV!W4pVeV#\ RV: R\ V4: RV: RV: 24h)z=Convert ``element`` to ``self.dtype`` given the base domain. from_Cannot convert of type z from  to )rr,r-getattrr type)relementbasemethod_convertresults&&& r convert_fromDomain.convert_fromsp :: !tzz)Ft~~666F4(  g,F! WVZ[bVceikopqqr"c Ve5\V4'd\RV,4hVPW4#VPV4'dV#\V4'd\RV,4h^RIHpHpHpHpVPV4'dVPW4#\V\4'dVPV!V4V4#\R8wdY\WP4'dVPW4#\WP4'dVPW4#\V\4'd V!4pVPV!V4V4#\V\4'd V!4pVPV!V4V4#\V4P R8Xd V!4pVPV!V4V4#\V4P R8Xd V!4pVPV!V4V4#\V\"4'd VPWP%44#VP&'d3\)VRR4'd VP+VP-44#\V\.4'dVP1V4#\7V4'g7\9VRR 7p\V\.4'dVP1V4#\R V: R \V4: R V: 24h \2\43dL3i;i \2\43dLJi;i) z'Convert ``element`` to ``self.dtype``. z%s is not in any domain)ZZQQ RealField ComplexFieldpythonmpfmpc is_groundFT)strictrBrCrD)rr rLof_typesympy.polys.domainsrOrPrQrR isinstanceintrr8floatcomplexrFr-r parent is_NumericalrEconvertLCr from_sympy TypeError ValueErrorrr)rrGrHrOrPrQrRr^s&&& rr`Domain.converts  G$$$%>%HII$$W3 3 << N   !:W!DE EGG ::g  $$W1 1 gs # #$$R["5 5 8 #'55))((55'55))((55 gu % %[F$$VG_f= = gw ' '!^F$$VG_f= = = ! !U *[F$$VG_f= = = ! !U *!^F$$VG_f= = g} - -$$Wnn.>? ?    +u!E!E<< - - gu % % w//w''%gd;G!'511#w772 WdSZm]abccz*  ":.s$&L 3L5L21L25M M c ,\WP4#)z%Check if ``a`` is of type ``dtype``. )rZr8)rrGs&&rrXDomain.of_types'77++r"c |\V4'd\hVPV4R# \dR#i;i)z'Check if ``a`` belongs to this domain. FT)rr r`ras&&r __contains__Domain.__contains__s: A$$ LLO  s (, ;;c \h)aConvert domain element *a* to a SymPy expression (Expr). Explanation =========== Convert a :py:class:`~.Domain` element *a* to :py:class:`~.Expr`. Most public SymPy functions work with objects of type :py:class:`~.Expr`. The elements of a :py:class:`~.Domain` have a different internal representation. It is not possible to mix domain elements with :py:class:`~.Expr` so each domain has :py:meth:`~.Domain.to_sympy` and :py:meth:`~.Domain.from_sympy` methods to convert its domain elements to and from :py:class:`~.Expr`. Parameters ========== a: domain element An element of this :py:class:`~.Domain`. Returns ======= expr: Expr A normal SymPy expression of type :py:class:`~.Expr`. Examples ======== Construct an element of the :ref:`QQ` domain and then convert it to :py:class:`~.Expr`. >>> from sympy import QQ, Expr >>> q_domain = QQ(2) >>> q_domain 2 >>> q_expr = QQ.to_sympy(q_domain) >>> q_expr 2 Although the printed forms look similar these objects are not of the same type. >>> isinstance(q_domain, Expr) False >>> isinstance(q_expr, Expr) True Construct an element of :ref:`K[x]` and convert to :py:class:`~.Expr`. >>> from sympy import Symbol >>> x = Symbol('x') >>> K = QQ[x] >>> x_domain = K.gens[0] # generator x as a domain element >>> p_domain = x_domain**2/3 + 1 >>> p_domain 1/3*x**2 + 1 >>> p_expr = K.to_sympy(p_domain) >>> p_expr x**2/3 + 1 The :py:meth:`~.Domain.from_sympy` method is used for the opposite conversion from a normal SymPy expression to a domain element. >>> p_domain == p_expr False >>> K.from_sympy(p_expr) == p_domain True >>> K.to_sympy(p_domain) == p_expr True >>> K.from_sympy(K.to_sympy(p_domain)) == p_domain True >>> K.to_sympy(K.from_sympy(p_expr)) == p_expr True The :py:meth:`~.Domain.from_sympy` method makes it easier to construct domain elements interactively. >>> from sympy import Symbol >>> x = Symbol('x') >>> K = QQ[x] >>> K.from_sympy(x**2/3 + 1) 1/3*x**2 + 1 See also ======== from_sympy convert_from rris&&rto_sympyDomain.to_sympys v"!r"c \h)ajConvert a SymPy expression to an element of this domain. Explanation =========== See :py:meth:`~.Domain.to_sympy` for explanation and examples. Parameters ========== expr: Expr A normal SymPy expression of type :py:class:`~.Expr`. Returns ======= a: domain element An element of this :py:class:`~.Domain`. See also ======== to_sympy convert_from rris&&rrbDomain.from_sympyBs 4"!r"c .\WPR7#))start)sumrr2s&&rrt Domain.sum^s4yy))r"c R#z.Convert ``ModularInteger(int)`` to ``dtype``. NK1rjK0s&&&rfrom_FFDomain.from_FFar"c R#rwrxrys&&&rfrom_FF_pythonDomain.from_FF_pythoner~r"c R#)z.Convert a Python ``int`` object to ``dtype``. Nrxrys&&&rfrom_ZZ_pythonDomain.from_ZZ_pythonir~r"c R#)z3Convert a Python ``Fraction`` object to ``dtype``. Nrxrys&&&rfrom_QQ_pythonDomain.from_QQ_pythonmr~r"c R#)z.Convert ``ModularInteger(mpz)`` to ``dtype``. Nrxrys&&&r from_FF_gmpyDomain.from_FF_gmpyqr~r"c R#)z,Convert a GMPY ``mpz`` object to ``dtype``. Nrxrys&&&r from_ZZ_gmpyDomain.from_ZZ_gmpyur~r"c R#)z,Convert a GMPY ``mpq`` object to ``dtype``. Nrxrys&&&r from_QQ_gmpyDomain.from_QQ_gmpyyr~r"c R#)z,Convert a real element object to ``dtype``. Nrxrys&&&rfrom_RealFieldDomain.from_RealField}r~r"c R#)z(Convert a complex element to ``dtype``. Nrxrys&&&rfrom_ComplexFieldDomain.from_ComplexFieldr~r"c R#)z*Convert an algebraic number to ``dtype``. Nrxrys&&&rfrom_AlgebraicFieldDomain.from_AlgebraicFieldr~r"c vVP'd'VPVPVP4#R#z#Convert a polynomial to ``dtype``. N)rVr`radomrys&&&rfrom_PolynomialRingDomain.from_PolynomialRings) ;;;::addBFF+ + r"c R#)z*Convert a rational function to ``dtype``. Nrxrys&&&rfrom_FractionFieldDomain.from_FractionFieldr~r"c NVPVPVP4#)z.Convert an ``ExtensionElement`` to ``dtype``. )rLrringrys&&&rfrom_MonogenicFiniteExtension$Domain.from_MonogenicFiniteExtensionsquubgg..r"c 8VPVP4#z&Convert a ``EX`` object to ``dtype``. )rbexrys&&&rfrom_ExpressionDomainDomain.from_ExpressionDomains}}QTT""r"c $VPV4#r)rbrys&&&rfrom_ExpressionRawDomainDomain.from_ExpressionRawDomains}}Qr"c VP4^8:d+VPVP4VP4#R#r)degreer`rarrys&&&rfrom_GlobalPolynomialRing Domain.from_GlobalPolynomialRings/ 88:?::addfbff- - r"c $VPW4#r)rrys&&&rfrom_GeneralizedPolynomialRing%Domain.from_GeneralizedPolynomialRings$$Q++r"c  ZVP'd,\VP4\V4,'g>VP'dM\VP4\V4,'d"\RV: RV: R\ V4: R24hVP V4#) Cannot unify  with z, given z generators) is_Compositesetsymbolsr tupleunify)r{rzrs&&&runify_with_symbolsDomain.unify_with_symbolssp OOORZZ3w,>,>FOOO&&&__&F ???BOOOr7J7J7JbNbNbNb,,C,,C P  &v' '6E**r"c VeVPW4#W8XdV#VP'dVP'gHVP4VP48wd\RV: RV: 24hVP V4#VP 'dV#VP 'dV#VP 'dV#VP 'dV#VP'gVP'dVP'dYrVP'dT\\VPVP.44^,VP8XdYrVPV4#VPVP4pVPPV4pVPV4#VP 'gVP 'dVP V4#VP"'dYrVP"'d]VP"'gVP$'d7VP&VP&8dV#^RIHpV!VP&R7#V#VP$'dYrVP$'dqVP$'d VP&VP&8dV#V#VP,'gVP.'d^RIHpV!VP&R7#V#VP0'dYrVP0'dVP,'dVP34pVP.'dVP54pVP0'dVVP6!VP8PVP84.\;VP<VP<4O5!#V#VP.'dV#VP.'dV#VP,'d%VP>'dVP34pV#VP,'d%VP>'dVP34pV#VP>'dV#VP>'dV#VP@'dV#VP@'dV#^RI!H"pV#)z Construct a minimal domain that contains elements of ``K0`` and ``K1``. Known domains (from smallest to largest): - ``GF(p)`` - ``ZZ`` - ``QQ`` - ``RR(prec, tol)`` - ``CC(prec, tol)`` - ``ALG(a, b, c)`` - ``K[x, y, z]`` - ``K(x, y, z)`` - ``EX`` rr)rR)prec)EX)#rhas_CharacteristicZerocharacteristicr ris_EXRAWis_EXis_FiniteExtensionlistrmodulus set_domaindropsymbolrrris_ComplexField is_RealField precision sympy.polys.domains.complexfieldrRis_GaussianRingis_GaussianFieldis_AlgebraicField get_fieldas_AlgebraicFieldr,rrorig_extis_RationalFieldis_IntegerRingrYr)r{rzrrRrs&&& rr Domain.unifys"  ((5 5 8I)))b.G.G.G  "b&7&7&99'R(LMM %%b) ) ;;;I ;;;I 888I 888I B$9$9$9$$$B$$$RZZ 89:1=K}}R((WWRYY'YY__R(}}R(( ???booo%%b) )      !!!R___<<2<</IM'R\\:: ??? ???<<2<</II###r':':':I#66      !!!\\^"""))+###||BFFLL$8a;r{{TVT_T_;`aa   I   I   """\\^I   """\\^I   I   I   I   I* r"c d\V\4;'dVPVP8H#)z0Returns ``True`` if two domains are equivalent. )rZrrrothers&&r__eq__ Domain.__eq__Ns&%(FFTZZ5;;-FFr"c W8X*#)z1Returns ``False`` if two domains are equivalent. rxrs&&r__ne__ Domain.__ne__Ss   r"c .pVFRp\V\4'd#VPVPV44K;VPV!V44KT V#)z5Rersively apply ``self`` to all elements of ``seq``. )rZrappendmap)rseqrKelts&& rr Domain.mapWsIC#t$$ dhhsm, d3i(   r"c &\RV,4h)z)Returns a ring associated with ``self``. z#there is no ring associated with %sr rs&rrDomain.get_ringcs?$FGGr"c &\RV,4h)z*Returns a field associated with ``self``. z$there is no field associated with %srrs&rrDomain.get_fieldgs@4GHHr"c V#)z2Returns an exact domain associated with ``self``. rxrs&r get_exactDomain.get_exactks r"c h\VR4'dVP!V!#VPV4#)z0The mathematical way to make a polynomial ring. __iter__)hasattr poly_ringrrs&&r __getitem__Domain.__getitem__os- 7J ' '>>7+ +>>'* *r"rc ^RIHpV!WV4#z(Returns a polynomial ring, i.e. `K[X]`. )PolynomialRing)"sympy.polys.domains.polynomialringr )rrrr s&$* rrDomain.poly_ringvsEdU33r"c ^RIHpV!WV4#z'Returns a fraction field, i.e. `K(X)`. ) FractionField)!sympy.polys.domains.fractionfieldr)rrrrs&$* r frac_fieldDomain.frac_field{sCTE22r"c &^RIHpV!V.VO5/VB#r)rr )rrkwargsr s&*, r old_poly_ringDomain.old_poly_ringsId7W777r"c &^RIHpV!V.VO5/VB#r )%sympy.polys.domains.old_fractionfieldr)rrrrs&*, rold_frac_fieldDomain.old_frac_fieldsGT6G6v66r"c &\RV,4h)z6Returns an algebraic field, i.e. `K(\alpha, \ldots)`. z%Cannot create algebraic field over %sr)rr extensions&$*ralgebraic_fieldDomain.algebraic_fieldsADHIIr"c Z^RIHpV!W4p\WRR7pVPWbR7#)a Convenience method to construct an algebraic extension on a root of a polynomial, chosen by root index. Parameters ========== poly : :py:class:`~.Poly` The polynomial whose root generates the extension. alias : str, optional (default=None) Symbol name for the generator of the extension. E.g. "alpha" or "theta". root_index : int, optional (default=-1) Specifies which root of the polynomial is desired. The ordering is as defined by the :py:class:`~.ComplexRootOf` class. The default of ``-1`` selects the most natural choice in the common cases of quadratic and cyclotomic fields (the square root on the positive real or imaginary axis, resp. $\mathrm{e}^{2\pi i/n}$). Examples ======== >>> from sympy import QQ, Poly >>> from sympy.abc import x >>> f = Poly(x**2 - 2) >>> K = QQ.alg_field_from_poly(f) >>> K.ext.minpoly == f True >>> g = Poly(8*x**3 - 6*x - 1) >>> L = QQ.alg_field_from_poly(g, "alpha") >>> L.ext.minpoly == g True >>> L.to_sympy(L([1, 1, 1])) alpha**2 + alpha + 1 )CRootOf)r)sympy.polys.rootoftoolsrrr)rpolyr root_indexrrootalphas&&&& ralg_field_from_polyDomain.alg_field_from_polys0J 4t(2##E#77r"c v^RIHpV'dV\V4, pVPV!W4VVR7#)a Convenience method to construct a cyclotomic field. Parameters ========== n : int Construct the nth cyclotomic field. ss : boolean, optional (default=False) If True, append *n* as a subscript on the alias string. alias : str, optional (default="zeta") Symbol name for the generator. gen : :py:class:`~.Symbol`, optional (default=None) Desired variable for the cyclotomic polynomial that defines the field. If ``None``, a dummy variable will be used. root_index : int, optional (default=-1) Specifies which root of the polynomial is desired. The ordering is as defined by the :py:class:`~.ComplexRootOf` class. The default of ``-1`` selects the root $\mathrm{e}^{2\pi i/n}$. Examples ======== >>> from sympy import QQ, latex >>> K = QQ.cyclotomic_field(5) >>> K.to_sympy(K([-1, 1])) 1 - zeta >>> L = QQ.cyclotomic_field(7, True) >>> a = L.to_sympy(L([-1, 1])) >>> print(a) 1 - zeta7 >>> print(latex(a)) 1 - \zeta_{7} )cyclotomic_poly)rr")sympy.polys.specialpolysr(r'r%)rnssrgenr"r(s&&&&&& rcyclotomic_fieldDomain.cyclotomic_fields<H = SVOE''(?u3=(? ?r"c \h)z$Inject generators into this domain. rrs&*rinject Domain.inject!!r"c 6VP'dV#\h)z"Drop generators from this domain. ) is_Simplerrs&*rr Domain.drops >>>K!!r"c V'*#)zReturns True if ``a`` is zero. rxris&&ris_zeroDomain.is_zeros u r"c WP8H#)zReturns True if ``a`` is one. )rris&&ris_one Domain.is_onesHH}r"c V^8#)z#Returns True if ``a`` is positive. rxris&&r is_positiveDomain.is_positive 1u r"c V^8#)z#Returns True if ``a`` is negative. rxris&&r is_negativeDomain.is_negativer?r"c V^8*#)z'Returns True if ``a`` is non-positive. rxris&&ris_nonpositiveDomain.is_nonpositive Av r"c V^8#)z'Returns True if ``a`` is non-negative. rxris&&ris_nonnegativeDomain.is_nonnegativerFr"c bVPV4'dVP)#VP#r)rArris&&rcanonical_unitDomain.canonical_units(   A  HH9 88Or"c \V4#)z.Absolute value of ``a``, implies ``__abs__``. )absris&&rrN Domain.abs s 1v r"c V)#)z,Returns ``a`` negated, implies ``__neg__``. rxris&&rneg Domain.neg r r"c V5#)z-Returns ``a`` positive, implies ``__pos__``. rxris&&rpos Domain.posrSr"c W,#)z.Sum of ``a`` and ``b``, implies ``__add__``. rxrrjbs&&&radd Domain.add u r"c W, #)z5Difference of ``a`` and ``b``, implies ``__sub__``. rxrXs&&&rsub Domain.subr\r"c W,#)z2Product of ``a`` and ``b``, implies ``__mul__``. rxrXs&&&rmul Domain.mulr\r"c W,#)z2Raise ``a`` to power ``b``, implies ``__pow__``. rxrXs&&&rpow Domain.pow"s v r"c \h)a Exact quotient of *a* and *b*. Analogue of ``a / b``. Explanation =========== This is essentially the same as ``a / b`` except that an error will be raised if the division is inexact (if there is any remainder) and the result will always be a domain element. When working in a :py:class:`~.Domain` that is not a :py:class:`~.Field` (e.g. :ref:`ZZ` or :ref:`K[x]`) ``exquo`` should be used instead of ``/``. The key invariant is that if ``q = K.exquo(a, b)`` (and ``exquo`` does not raise an exception) then ``a == b*q``. Examples ======== We can use ``K.exquo`` instead of ``/`` for exact division. >>> from sympy import ZZ >>> ZZ.exquo(ZZ(4), ZZ(2)) 2 >>> ZZ.exquo(ZZ(5), ZZ(2)) Traceback (most recent call last): ... ExactQuotientFailed: 2 does not divide 5 in ZZ Over a :py:class:`~.Field` such as :ref:`QQ`, division (with nonzero divisor) is always exact so in that case ``/`` can be used instead of :py:meth:`~.Domain.exquo`. >>> from sympy import QQ >>> QQ.exquo(QQ(5), QQ(2)) 5/2 >>> QQ(5) / QQ(2) 5/2 Parameters ========== a: domain element The dividend b: domain element The divisor Returns ======= q: domain element The exact quotient Raises ====== ExactQuotientFailed: if exact division is not possible. ZeroDivisionError: when the divisor is zero. See also ======== quo: Analogue of ``a // b`` rem: Analogue of ``a % b`` div: Analogue of ``divmod(a, b)`` Notes ===== Since the default :py:attr:`~.Domain.dtype` for :ref:`ZZ` is ``int`` (or ``mpz``) division as ``a / b`` should not be used as it would give a ``float`` which is not a domain element. >>> ZZ(4) / ZZ(2) # doctest: +SKIP 2.0 >>> ZZ(5) / ZZ(2) # doctest: +SKIP 2.5 On the other hand with `SYMPY_GROUND_TYPES=flint` elements of :ref:`ZZ` are ``flint.fmpz`` and division would raise an exception: >>> ZZ(4) / ZZ(2) # doctest: +SKIP Traceback (most recent call last): ... TypeError: unsupported operand type(s) for /: 'fmpz' and 'fmpz' Using ``/`` with :ref:`ZZ` will lead to incorrect results so :py:meth:`~.Domain.exquo` should be used instead. rrXs&&&rexquo Domain.exquo&s r"!r"c \h)aQuotient of *a* and *b*. Analogue of ``a // b``. ``K.quo(a, b)`` is equivalent to ``K.div(a, b)[0]``. See :py:meth:`~.Domain.div` for more explanation. See also ======== rem: Analogue of ``a % b`` div: Analogue of ``divmod(a, b)`` exquo: Analogue of ``a / b`` rrXs&&&rquo Domain.quo "!r"c \h)aModulo division of *a* and *b*. Analogue of ``a % b``. ``K.rem(a, b)`` is equivalent to ``K.div(a, b)[1]``. See :py:meth:`~.Domain.div` for more explanation. See also ======== quo: Analogue of ``a // b`` div: Analogue of ``divmod(a, b)`` exquo: Analogue of ``a / b`` rrXs&&&rrem Domain.remrlr"c \h)a{Quotient and remainder for *a* and *b*. Analogue of ``divmod(a, b)`` Explanation =========== This is essentially the same as ``divmod(a, b)`` except that is more consistent when working over some :py:class:`~.Field` domains such as :ref:`QQ`. When working over an arbitrary :py:class:`~.Domain` the :py:meth:`~.Domain.div` method should be used instead of ``divmod``. The key invariant is that if ``q, r = K.div(a, b)`` then ``a == b*q + r``. The result of ``K.div(a, b)`` is the same as the tuple ``(K.quo(a, b), K.rem(a, b))`` except that if both quotient and remainder are needed then it is more efficient to use :py:meth:`~.Domain.div`. Examples ======== We can use ``K.div`` instead of ``divmod`` for floor division and remainder. >>> from sympy import ZZ, QQ >>> ZZ.div(ZZ(5), ZZ(2)) (2, 1) If ``K`` is a :py:class:`~.Field` then the division is always exact with a remainder of :py:attr:`~.Domain.zero`. >>> QQ.div(QQ(5), QQ(2)) (5/2, 0) Parameters ========== a: domain element The dividend b: domain element The divisor Returns ======= (q, r): tuple of domain elements The quotient and remainder Raises ====== ZeroDivisionError: when the divisor is zero. See also ======== quo: Analogue of ``a // b`` rem: Analogue of ``a % b`` exquo: Analogue of ``a / b`` Notes ===== If ``gmpy`` is installed then the ``gmpy.mpq`` type will be used as the :py:attr:`~.Domain.dtype` for :ref:`QQ`. The ``gmpy.mpq`` type defines ``divmod`` in a way that is undesirable so :py:meth:`~.Domain.div` should be used instead of ``divmod``. >>> a = QQ(1) >>> b = QQ(3, 2) >>> a # doctest: +SKIP mpq(1,1) >>> b # doctest: +SKIP mpq(3,2) >>> divmod(a, b) # doctest: +SKIP (mpz(0), mpq(1,1)) >>> QQ.div(a, b) # doctest: +SKIP (mpq(2,3), mpq(0,1)) Using ``//`` or ``%`` with :ref:`QQ` will lead to incorrect results so :py:meth:`~.Domain.div` should be used instead. rrXs&&&rdiv Domain.divs h"!r"c \h)z5Returns inversion of ``a mod b``, implies something. rrXs&&&rinvert Domain.invertr2r"c \h)z!Returns ``a**(-1)`` if possible. rris&&rrevert Domain.revertr2r"c \h)zReturns numerator of ``a``. rris&&rnumer Domain.numerr2r"c \h)zReturns denominator of ``a``. rris&&rdenom Domain.denomr2r"c 0VPW4wr4pW53#)z&Half extended GCD of ``a`` and ``b``. )gcdex)rrjrYsths&&& r half_gcdexDomain.half_gcdexs**Q"at r"c \h)z!Extended GCD of ``a`` and ``b``. rrXs&&&rr Domain.gcdex r2r"c pVPW4pVPW4pVPW#4pW4V3#)z.Returns GCD and cofactors of ``a`` and ``b``. )gcdrj)rrjrYrcfacfbs&&& r cofactorsDomain.cofactorss5hhqnhhqhhq}r"c \h)z Returns GCD of ``a`` and ``b``. rrXs&&&rr Domain.gcdr2r"c \h)z Returns LCM of ``a`` and ``b``. rrXs&&&rlcm Domain.lcmr2r"c \h)z#Returns b-base logarithm of ``a``. rrXs&&&rlog Domain.logr2r"c \h)aReturns a (possibly inexact) square root of ``a``. Explanation =========== There is no universal definition of "inexact square root" for all domains. It is not recommended to implement this method for domains other then :ref:`ZZ`. See also ======== exsqrt rris&&rsqrt Domain.sqrt!rlr"c \h)a>Returns whether ``a`` is a square in the domain. Explanation =========== Returns ``True`` if there is an element ``b`` in the domain such that ``b * b == a``, otherwise returns ``False``. For inexact domains like :ref:`RR` and :ref:`CC`, a tiny difference in this equality can be tolerated. See also ======== exsqrt rris&&r is_squareDomain.is_square0s "!r"c \h)aPrincipal square root of a within the domain if ``a`` is square. Explanation =========== The implementation of this method should return an element ``b`` in the domain such that ``b * b == a``, or ``None`` if there is no such ``b``. For inexact domains like :ref:`RR` and :ref:`CC`, a tiny difference in this equality can be tolerated. The choice of a "principal" square root should follow a consistent rule whenever possible. See also ======== sqrt, is_square rris&&rexsqrt Domain.exsqrt@s "!r"c FVPV4P!V3/VB#)z*Returns numerical approximation of ``a``. )rnevalf)rrjroptionss&&&,rr Domain.evalfQs!}}Q%%d6g66r"c V#rrxris&&rreal Domain.realWsr"c VP#r)rris&&rimag Domain.imagZs yyr"c W8H#)z+Check if ``a`` and ``b`` are almost equal. rx)rrjrY tolerances&&&&ralmosteqDomain.almosteq]s v r"c \R4h)z*Return the characteristic of this domain. zcharacteristic()rrs&rrDomain.characteristicas!"455r"rxr)N)FzetaNr)r- __module__ __qualname____firstlineno____doc__r__annotations__rris_Ringrrhas_assoc_Fieldis_FiniteFieldis_FFris_ZZris_QQris_ZZ_Iris_QQ_Iris_RRris_CCr is_Algebraicris_Polyris_Fracis_SymbolicDomainris_SymbolicRawDomainrris_Exactr_r4ris_PIDrrrr r$r(r.r4propertyr8r;r>rLr`rXrkrnrbrtr|rrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrr%r-r0rr7r:r=rArDrHrKrNrQrUrZr^rardrgrjrnrqrtrwrzr}rrrrrrrrrrr*rrrr__static_attributes__rxr"rrrshTE;,D# CO G$H"N O #"NU""NU$$u %%Og!&&w  L5##Oe',, "''!&&w %%&++8HLIL F"#CE:";!!r"AdF, ["z"8*, /# . , +BBG ! HI+44 33 8 7 JJ(8T(?T""  Y"v " "T"l"""" """" "" ""7 A6r"rN)r __future__rtypingrsympy.core.numbersr sympy.corerrsympy.core.sortingrsympy.external.gmpyr!sympy.polys.domains.domainelementr sympy.polys.orderingsr sympy.polys.polyerrorsr r r sympy.polys.polyutilsrrsympy.utilitiesrsympy.utilities.iterablesrr__all__rxr"rrsU/".%&,;%QQ;"1P6P6P6f* *r"