\hHSrSSKJrJr SSKJr SSKJr SSKJ r J r J r J r SSK Jr SSKJrJr SSKJr SS KJrJr \SS j5rS rS rSrSrSrSrSrSrSr Sr!Sr"Sr#"SS5r$\"SS\55r%g )z@Tools and arithmetics for monomials of distributed polynomials. )combinations_with_replacementproduct)dedent)cacheit)MulSTuplesympify)ExactQuotientFailed)PicklableWithSlotsdict_from_expr)public) is_sequenceiterableNc#X^^# [T5(Ga[U5n[T5U:wa [S5eTcS/U-mOW[T5(d [S5e[T5U:wa [S5e[ST55(a [S5e[UU4Sj[ U555(a [S5e/n[ UTT5H6upVnUR [ XgS -5Vs/sHoU-PM sn5 M8 [U6H n [U 6v M gTn U S:a [S 5eTcSn OTS:a [S 5eTn X:agU(aU S:Xa[Rv g[U5[R/-n[S U55(a [X 5n O [X S 9n [5n X- nU H;nSnUHnUS :XdM US - nUU:dM M" U R[U65 M= U ShvN gs snfN 7f)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 M/var/www/auris/envauris/lib/python3.13/site-packages/sympy/polys/monomials.py itermonomials..cs.+Qq5+z+min_degrees cannot contain negative numbersc3:># UHnTUTU:v M g7fNr)rr max_degrees min_degreess rrresA1{1~ A.sz2min_degrees[i] must be <= max_degrees[i] for all izmax_degrees cannot be negativezmin_degrees cannot be negativec38# UHoRv M g7fr)is_commutative)rvariables rrr}sAy8&&ys)repeat)rlen ValueErroranyrangezipappendrrrOnelistallrsetadd) variablesrrn power_listsvarmin_dmax_drpowers max_degree min_degreeit monomials_setditemcountr"s `` r itermonomialsr=sT;  N { q :; ;  #a%K[))89 9;1$ !>??.+... !NOO AaA A AQR R !$Y [!I C   eQY0GH0G1Q0GH I"J{+Fv, ,! >=> >  JQ !ABB$J  " J!O%%K Oquug- AyA A A.yEB6B  #DE q=QJE5y ! !!#t*-!  G IF !s+C7H*;H# CH*+ H*8%H*H( H*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_countrCs'<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`. tupler(ABabs r monomial_mulrMs)" 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,rG)rIrJCs r monomial_divrUs+, aA 1 QxrDcd[[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`. rFrHs rrSrSs), SY0YTQ15Y0 110rNcH[UVs/sHo"U-PM sn5$s snf)z%Return the n-th pow of the monomial. )rG)rIr0rKs r monomial_powrXs! #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`. )rGr(minrHs 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`. )rGr(maxrHs r monomial_lcmr`r\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)rrKrLs rr#monomial_divides...s,)$!qv)s)r,r()rIrJs rmonomial_dividesrd!s ,#a), ,,rDc[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_rGmonomsMrBrr0s r monomial_maxrj0K" 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+rfrZrGrgs r monomial_minrmIrkrDc[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 )sum)ris r monomial_degrpbs  q6MrDcUup4UupV[X55nUR(aUbXrRXF54$gUbXF-(dXrRXF54$g)z,Division of two terms in over a ring/field. N)rUis_Fieldquo)rKrLdomaina_lma_lcb_lmb_lcmonoms rterm_divrzqsZJDJD  $E   **T00 0 **T00 0rDc^\rSrSrSr\U4Sj5rSrSrSr \S5r \S5r \S 5r \S 5r \S 5r\S 5r\S 5rSrU=r$) MonomialOpsiz6Code generator of fast monomial arithmetic functions. c2>[TU]U5nXlU$r)super__new__ngens)clsrobj __class__s rrMonomialOps.__new__sgoc"  rDcUR4$r)rselfs r__getnewargs__MonomialOps.__getnewargs__s }rDc$0n[X5 X2$r)exec)rcodenamenss r_buildMonomialOps._builds  TxrDcb[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)NrMs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) rKrL + , rrIrJABrrr(joinr rrtemplaterIrJrKrLrrs rmulMonomialOps.muls   JJsO JJsO.1!i 9idaAq!i 9diil1UYU^U^_aUbcc{{4&&:BcSn[S5nURS5nUVs/sHnSU-PM nnX!SRU5SRU5S.-nURXa5$s snf)NrXzZ def %(name)s(A, k): (%(A)s,) = A return (%(Ak)s,) rKz%s*kr)rrIAk)rrrr)rrrrIrKrrs 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,) rKrLrz*kr)rrIrJABkr) rrrrIrJrKrLrrs rmulpowMonomialOps.mulpows    JJsO JJsO14Q<q!$<diil1VZV_V_`cVdee{{4&&=sBcFSn[S5nURS5nURS5n[X45VVs/sHupVU<SU<3PM nnnX!SRU5SRU5SRU5S.-nUR X5$s snnf)NrSrrKrLz - 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) NrUz def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B %(RAB)s return (%(R)s,) rKrLz7r%(i)s = a%(i)s - b%(i)s if r%(i)s < 0: return Nonerrrz )rrIrJRABR)rrr'rrr) rrrrIrJrrrrs 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) Nr`rrKrL 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[rrKrLrz <= rrrrrs rgcdMonomialOps.gcdrrr)__name__ __module__ __qualname____firstlineno____doc__rrrrrrrrrrrr__static_attributes__ __classcell__)rs@rr|r|s@    A  '  '  '  '  '  '  '  ' ' '   '  '  '  'rDr|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+valueskeysr%formatrGmapintrr)rryrreps r__init__Monomial.__init__s&wu~DAIC3x1}cjjl!3A!6!!;SXXZ(+ !=!D!DU!KLLs3/ rDcJURX=(d UR5$r)rr)rrrs rrebuildMonomial.rebuilds~~i):;;rDc,[UR5$r)r$rrs r__len__Monomial.__len__s4>>""rDc,[UR5$r)iterrrs r__iter__Monomial.__iter__sDNN##rDc URU$r)r)rr;s r __getitem__Monomial.__getitem__s~~d##rDcn[URRURUR45$r)hashrrrrrs r__hash__Monomial.__hash__s&T^^,,dnndiiHIIrDc UR(aKSR[URUR5VVs/sHupU<SU<3PM snn5$URR <SUR<S3$s snnf)N*z**())rrr(rrr)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%rr(r)rrrrs ras_exprMonomial.as_expr&sX tyyG$NP Ps4/HJ/H83ch/HJKKJsA c[U[5(a URnO[U[[45(aUnOgURU:H$)NF) isinstancerrrGr rotherrs r__eq__Monomial.__eq__0s@ eX & &I u~ . .I~~**rDc X:X+$rr)rrs r__ne__Monomial.__ne__:s   rDc[U[5(a URnO$[U[[45(aUnO[ eUR [URU55$r)rrrrGr NotImplementedErrorrrMrs r__mul__Monomial.__mul__=sN eX & &I u~ . .I% %||LCDDrDc [U[5(a URnO$[U[[45(aUnO[ e[ URU5nUbURU5$[U[U55er) rrrrGr rrUrr )rrrresults r __truediv__Monomial.__truediv__Gsj eX & &I u~ . .I% %dnni8  <<' '%dHUO< rsF=$--6D";}!}!~:B2&:20%6&6& -22 ${'{'zsE!sEsErD