ЦiISrSSKJrJr SSKJr SSKJrJrJ r J r SSK J r SSK JrJr SSKJr SSKJrJr \SS j5rS rS rS rSrSrSrSrSrSrSrSr Sr!"SS5r"\"SS\55r#g )z@Tools and arithmetics for monomials of distributed polynomials. )combinations_with_replacementproduct)dedent)MulSTuplesympify)ExactQuotientFailed)PicklableWithSlotsdict_from_expr)public) is_sequenceiterableNc#^^# [U5n[T5(a~[T5U:wa [S5eTcS/U-mOW[T5(d [S5e[T5U:wa [S5e[ST55(a [S5eSnO.TnUS:a [S5eTcSnOTS:a [S 5eTnS nU(Ga{WW:agU(aUS:Xa[R v g[ U5[R /-n[S U55(a/n[X5Hln[RUS5n UHn U S :wdM X==S - ss'M [U R55U:dMUUR[U65 Mn [U5ShvN g/n [!XS 9Hln[RUS5n UHn U S :wdM X==S - ss'M [U R55U:dMUU R[U65 Mn [U 5ShvN g[UU4Sj[#U555(a [S5e/n [%UTT5H7upnU R[#XS -5Vs/sHnU U-PM sn5 M9 [!U 6H n [U 6v M gGN(Ns snf7f)a ``max_degrees`` and ``min_degrees`` are either both integers or both lists. Unless otherwise specified, ``min_degrees`` is either ``0`` or ``[0, ..., 0]``. A generator of all monomials ``monom`` is returned, such that either ``min_degree <= total_degree(monom) <= max_degree``, or ``min_degrees[i] <= degree_list(monom)[i] <= max_degrees[i]``, for all ``i``. Case I. ``max_degrees`` and ``min_degrees`` are both integers ============================================================= Given a set of variables $V$ and a min_degree $N$ and a max_degree $M$ generate a set of monomials of degree less than or equal to $N$ and greater than or equal to $M$. The total number of monomials in commutative variables is huge and is given by the following formula if $M = 0$: .. math:: \frac{(\#V + N)!}{\#V! N!} For example if we would like to generate a dense polynomial of a total degree $N = 50$ and $M = 0$, which is the worst case, in 5 variables, assuming that exponents and all of coefficients are 32-bit long and stored in an array we would need almost 80 GiB of memory! Fortunately most polynomials, that we will encounter, are sparse. Consider monomials in commutative variables $x$ and $y$ and non-commutative variables $a$ and $b$:: >>> from sympy import symbols >>> from sympy.polys.monomials import itermonomials >>> from sympy.polys.orderings import monomial_key >>> from sympy.abc import x, y >>> sorted(itermonomials([x, y], 2), key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2] >>> sorted(itermonomials([x, y], 3), key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2, x**3, x**2*y, x*y**2, y**3] >>> a, b = symbols('a, b', commutative=False) >>> set(itermonomials([a, b, x], 2)) {1, a, a**2, b, b**2, x, x**2, a*b, b*a, x*a, x*b} >>> sorted(itermonomials([x, y], 2, 1), key=monomial_key('grlex', [y, x])) [x, y, x**2, x*y, y**2] Case II. ``max_degrees`` and ``min_degrees`` are both lists =========================================================== If ``max_degrees = [d_1, ..., d_n]`` and ``min_degrees = [e_1, ..., e_n]``, the number of monomials generated is: .. math:: (d_1 - e_1 + 1) (d_2 - e_2 + 1) \cdots (d_n - e_n + 1) Let us generate all monomials ``monom`` in variables $x$ and $y$ such that ``[1, 2][i] <= degree_list(monom)[i] <= [2, 4][i]``, ``i = 0, 1`` :: >>> from sympy import symbols >>> from sympy.polys.monomials import itermonomials >>> from sympy.polys.orderings import monomial_key >>> from sympy.abc import x, y >>> sorted(itermonomials([x, y], [2, 4], [1, 2]), reverse=True, key=monomial_key('lex', [x, y])) [x**2*y**4, x**2*y**3, x**2*y**2, x*y**4, x*y**3, x*y**2] zArgument sizes do not matchNrzmin_degrees is not a listc3*# UH oS:v M g7frN).0is T/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/polys/monomials.py itermonomials..bs.+Qq5+z+min_degrees cannot contain negative numbersFzmax_degrees cannot be negativezmin_degrees cannot be negativeTc38# UHoRv M g7fN)is_commutative)rvariables rrrxsAy8&&ys)repeatc3:># UHnTUTU:v M g7frr)rr max_degrees min_degreess rrrsA1{1~ A.sz2min_degrees[i] must be <= max_degrees[i] for all i)lenr ValueErroranyrOnelistallrdictfromkeyssumvaluesappendrsetrrangezip) variablesr!r"n total_degree max_degree min_degreemonomials_list_commitempowersrmonomials_list_non_comm power_listsvarmin_dmax_drs `` r itermonomialsr> sT IA; { q :; ;  #a%K[))89 9;1$ !>??.+... !NOO  >=> >  JQ !ABB$J   " J!O%%K Oquug- AyA A A"$ 5iLy!4 $H1}(A-(!%v}}':5'..sDz: M./ / /&( # =y!4 $H1}(A-(!%v}}':5+223:> >23 3 3 AaA A AQR R !$Y [!I C   eQY0GH0G1Q0GH I"J{+Fv, ,# 0 4 IsOEK,"+K,)K,:K";2K,1+K, )K, K% A$K,.K' =&K,%K,'K,cFSSKJn U"X-5U"U5- U"U5- $)a Computes the number of monomials. The number of monomials is given by the following formula: .. math:: \frac{(\#V + N)!}{\#V! N!} where `N` is a total degree and `V` is a set of variables. Examples ======== >>> from sympy.polys.monomials import itermonomials, monomial_count >>> from sympy.polys.orderings import monomial_key >>> from sympy.abc import x, y >>> monomial_count(2, 2) 6 >>> M = list(itermonomials([x, y], 2)) >>> sorted(M, key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2] >>> len(M) 6 r) factorial)(sympy.functions.combinatorial.factorialsr@)VNr@s rmonomial_countrDs'<C QU il *Yq\ 99cd[[X5VVs/sH up#X#-PM snn5$s snnf)a Multiplication of tuples representing monomials. Examples ======== Lets multiply `x**3*y**4*z` with `x*y**2`:: >>> from sympy.polys.monomials import monomial_mul >>> monomial_mul((3, 4, 1), (1, 2, 0)) (4, 6, 1) which gives `x**4*y**5*z`. tupler0ABabs r monomial_mulrNs)" SY0YTQ15Y0 110, c^[X5n[SU55(a [U5$g)al Division of tuples representing monomials. Examples ======== Lets divide `x**3*y**4*z` by `x*y**2`:: >>> from sympy.polys.monomials import monomial_div >>> monomial_div((3, 4, 1), (1, 2, 0)) (2, 2, 1) which gives `x**2*y**2*z`. However:: >>> monomial_div((3, 4, 1), (1, 2, 2)) is None True `x*y**2*z**2` does not divide `x**3*y**4*z`. c3*# UH oS:v M g7frr)rcs rrmonomial_div..s 1a61rN) monomial_ldivr(rH)rJrKCs r monomial_divrVs+, aA 1 QxrEcd[[X5VVs/sH up#X#- PM snn5$s snnf)aU Division of tuples representing monomials. Examples ======== Lets divide `x**3*y**4*z` by `x*y**2`:: >>> from sympy.polys.monomials import monomial_ldiv >>> monomial_ldiv((3, 4, 1), (1, 2, 0)) (2, 2, 1) which gives `x**2*y**2*z`. >>> monomial_ldiv((3, 4, 1), (1, 2, 2)) (2, 2, -1) which gives `x**2*y**2*z**-1`. rGrIs rrTrTs), SY0YTQ15Y0 110rOcH[UVs/sHo"U-PM sn5$s snf)z%Return the n-th pow of the monomial. )rH)rJr2rLs r monomial_powrYs! #1Q3# $$#sc r[[X5VVs/sHup#[X#5PM snn5$s snnf)a  Greatest common divisor of tuples representing monomials. Examples ======== Lets compute GCD of `x*y**4*z` and `x**3*y**2`:: >>> from sympy.polys.monomials import monomial_gcd >>> monomial_gcd((1, 4, 1), (3, 2, 0)) (1, 2, 0) which gives `x*y**2`. )rHr0minrIs r monomial_gcdr\+" Q43q94 5543 c r[[X5VVs/sHup#[X#5PM snn5$s snnf)a  Least common multiple of tuples representing monomials. Examples ======== Lets compute LCM of `x*y**4*z` and `x**3*y**2`:: >>> from sympy.polys.monomials import monomial_lcm >>> monomial_lcm((1, 4, 1), (3, 2, 0)) (3, 4, 1) which gives `x**3*y**4*z`. )rHr0maxrIs r monomial_lcmrar]r^c8[S[X555$)z Does there exist a monomial X such that XA == B? Examples ======== >>> from sympy.polys.monomials import monomial_divides >>> monomial_divides((1, 2), (3, 4)) True >>> monomial_divides((1, 2), (0, 2)) False c3.# UH upX:*v M g7frr)rrLrMs rr#monomial_divides..5s,)$!qv)s)r(r0)rJrKs rmonomial_dividesre(s ,#a), ,,rEc[US5nUSSH'n[U5Hup4[XU5X'M M) [U5$)ai Returns maximal degree for each variable in a set of monomials. Examples ======== Consider monomials `x**3*y**4*z**5`, `y**5*z` and `x**6*y**3*z**9`. We wish to find out what is the maximal degree for each of `x`, `y` and `z` variables:: >>> from sympy.polys.monomials import monomial_max >>> monomial_max((3,4,5), (0,5,1), (6,3,9)) (6, 5, 9) rrN)r' enumerater`rHmonomsMrCrr2s r monomial_maxrk7K" VAYA ABZaLDAqtQ>> from sympy.polys.monomials import monomial_min >>> monomial_min((3,4,5), (0,5,1), (6,3,9)) (0, 3, 1) rrN)r'rgr[rHrhs r monomial_minrnPrlrEc[U5$)z Returns the total degree of a monomial. Examples ======== The total degree of `xy^2` is 3: >>> from sympy.polys.monomials import monomial_deg >>> monomial_deg((1, 2)) 3 )r+)rjs r monomial_degrpis  q6MrEcUup4UupV[X55nUR(aUbXrRXF54$gUbXF-(dXrRXF54$g)z,Division of two terms in over a ring/field. N)rVis_Fieldquo)rLrMdomaina_lma_lcb_lmb_lcmonoms rterm_divrzxsZJDJD  $E   **T00 0 **T00 0rEcT\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rg) MonomialOpsiz6Code generator of fast monomial arithmetic functions. cXlgrngens)selfrs r__init__MonomialOps.__init__s rEc$0n[X5 X2$r)exec)rcodenamenss r_buildMonomialOps._builds  TxrEcb[UR5Vs/sH o!<U<3PM sn$s snfr)r/r)rrrs r_varsMonomialOps._varss*-24::->@->4#->@@@s,cFSn[S5nURS5nURS5n[X45VVs/sHupVU<SU<3PM nnnX!SRU5SRU5SRU5S.-nUR X5$s snnf)NrNs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) rLrM + , rrJrKABrrr0joinr rrtemplaterJrKrLrMrrs rmulMonomialOps.muls   JJsO JJsO.1!i 9idaAq!i 9diil1UYU^U^_aUbcc{{4&&:BcSn[S5nURS5nUVs/sHnSU-PM nnX!SRU5SRU5S.-nURXa5$s snf)NrYzZ def %(name)s(A, k): (%(A)s,) = A return (%(Ak)s,) rLz%s*kr)rrJAk)rrrr)rrrrJrLrrs rpowMonomialOps.powsp   JJsO#$ &1avz1 &diil$))B-PP{{4&&'sA+cHSn[S5nURS5nURS5n[X45VVs/sHupVU<SU<S3PM nnnX!SRU5SRU5SRU5S.-nUR X5$s snnf) Nmonomial_mulpowzw def %(name)s(A, B, k): (%(A)s,) = A (%(B)s,) = B return (%(ABk)s,) rLrMrz*kr)rrJrKABkr) rrrrJrKrLrMrrs rmulpowMonomialOps.mulpows    JJsO JJsO14Q<q!$<diil1VZV_V_`cVdee{{4&&=sBcFSn[S5nURS5nURS5n[X45VVs/sHupVU<SU<3PM nnnX!SRU5SRU5SRU5S.-nUR X5$s snnf)NrTrrLrMz - rrrrs rldivMonomialOps.ldivs   JJsO JJsO.1!i 9idaAq!i 9diil1UYU^U^_aUbcc{{4&&:rcSn[S5nURS5nURS5n[UR5Vs/sH nSSU0-PM nnURS5nX!SR U5SR U5S R U5SR U5S .-nUR X5$s snf) NrVz def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B %(RAB)s return (%(R)s,) rLrMz7r%(i)s = a%(i)s - b%(i)s if r%(i)s < 0: return Nonerrrz )rrJrKRABR)rrr/rrr) rrrrJrKrrrrs rdivMonomialOps.divs   JJsO JJsO_deieoeo_pr_pZ[JcSTXU_pr JJsOdiil1V^VcVcdgVhosoxoxyzo{||{{4&&ssCc VSn[S5nURS5nURS5n[X45VVs/sHupVU<SU<SU<SU<3PM nnnX!SRU5SRU5SRU5S .-nUR X5$s snnf) NrarrLrM if z >=  else rrrrs rlcmMonomialOps.lcm   JJsO JJsOCFq9 N9411aA69 Ndiil1UYU^U^_aUbcc{{4&&OB%c VSn[S5nURS5nURS5n[X45VVs/sHupVU<SU<SU<SU<3PM nnnX!SRU5SRU5SRU5S .-nUR X5$s snnf) Nr\rrLrMrz <= rrrrrs rgcdMonomialOps.gcdrrr~N)__name__ __module__ __qualname____firstlineno____doc__rrrrrrrrrr__static_attributes__rrErr|r|s8@ A ' ' ' '' ' 'rEr|c\rSrSrSrSrSSjrSSjrSrSr S r S r S r S r S rSrSrSr\rSrSrSrSrg)Monomializ9Class representing a monomial, i.e. a product of powers. ) exponentsgensNcb[U5(d{[[U5US9up2[U5S:Xa=[ UR 55SS:Xa[ UR 55SnO[SRU55e[[[U55Ul X l g)N)rrrzExpected a monomial got {})rr r r#r'r,keysr$formatrHmapintrr)rryrreps rrMonomial.__init__s&wu~DAIC3x1}cjjl!3A!6!!;SXXZ(+ !=!D!DU!KLLs3/ rEcJURX=(d UR5$r) __class__r)rrrs rrebuildMonomial.rebuild s~~i):;;rEc,[UR5$r)r#rrs r__len__Monomial.__len__s4>>""rEc,[UR5$r)iterrrs r__iter__Monomial.__iter__sDNN##rEc URU$r)r)rr7s r __getitem__Monomial.__getitem__s~~d##rEcn[URRURUR45$r)hashrrrrrs r__hash__Monomial.__hash__s&T^^,,dnndiiHIIrEc UR(aKSR[URUR5VVs/sHupU<SU<3PM snn5$URR <SUR<S3$s snnf)N*z**())rrr0rrr)rgenexps r__str__Monomial.__str__sa 9988C SWSaSaDbdDb#s3Dbde e#~~66G GesB cU=(d URnU(d[SU-5e[[XR5VVs/sH up#X#-PM snn6$s snnf)z3Convert a monomial instance to a SymPy expression. z5Cannot convert %s to an expression without generators)rr$rr0r)rrrrs ras_exprMonomial.as_expr sX tyyG$NP Ps4/HJ/H83ch/HJKKJsA c[U[5(a URnO[U[[45(aUnOgURU:H$)NF) isinstancerrrHrrotherrs r__eq__Monomial.__eq__*s@ eX & &I u~ . .I~~**rEc X:X+$rr)rrs r__ne__Monomial.__ne__4s   rEc[U[5(a URnO$[U[[45(aUnO[ eUR [URU55$r)rrrrHrNotImplementedErrorrrNrs r__mul__Monomial.__mul__7sN eX & &I u~ . .I% %||LCDDrEc [U[5(a URnO$[U[[45(aUnO[ e[ URU5nUbURU5$[U[U55er) rrrrHrrrVrr )rrrresults r __truediv__Monomial.__truediv__Asj eX & &I u~ . .I% %dnni8  <<' '%dHUO< rDrNrVrTrYr\rarerkrnrprzr|rrrErr sF=--6D";EEN:B2&:20%6&6& -22 $n'n'`sE!sEsErE