EdIdZddlmZmZddlmZddlmZmZm Z m Z ddl m Z ddl mZmZddlmZddlmZmZedd Zd Zd Zd ZdZdZdZdZdZdZdZdZ dZ!GddZ"eGddeZ#d S)z@Tools and arithmetics for monomials of distributed polynomials. )combinations_with_replacementproduct)dedent)MulSTuplesympify)ExactQuotientFailed)PicklableWithSlotsdict_from_expr)public) is_sequenceiterableNc #Kt|}trt|krtddg|znhtstdt|krtdtdDrtdd}n5}|dkrtdd}ndkrtd }d }|r||krdS|r|dkrtjVdSt |tjgz}td |Drg}t||D]j}d |D} |D]} | d kr| | xxd z cc<t| |kr| t|kt|Ed{VdSg} t||D]j}d|D} |D]} | d kr| | xxd z cc<t| |kr| t|kt| Ed{VdStfdt|Drtdg} t!|D]8\} }| fdt| |d zD9t| D] } t| VdS)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"K|] }|dkV dSrN.0is 5lib/python3.11/site-packages/sympy/polys/monomials.py z itermonomials..bs&..Q1q5......z+min_degrees cannot contain negative numbersFzmax_degrees cannot be negativezmin_degrees cannot be negativeTc3$K|] }|jV dSN)is_commutativervariables rrz itermonomials..xs%AA8x&AAAAAArci|]}|dSrrrs r z!itermonomials..{@@@((A@@@r)repeatci|]}|dSr rrs rr!z!itermonomials..r"rc3<K|]}||kVdSrr)rr max_degrees min_degreess rrz itermonomials..s0AA1{1~ A.AAAAAArz2min_degrees[i] must be <= max_degrees[i] for all icg|]}|zSrr)rrvars r z!itermonomials..sHHH1QHHHr)lenr ValueErroranyrOnelistallrsumvaluesappendrsetrrangezip) variablesr'r(n total_degree max_degree min_degreemonomials_list_commitempowersrmonomials_list_non_comm power_listsmin_dmax_dr*s `` @r itermonomialsrD sT IA; {  q  <:;; ;  P#a%KK[)) P899 9;1$ @ !>???..+..... P !NOOO  > ?=>> >  %JJQ C !ABBB$J #  "  F J!O %KKK FOOqug- AAyAAA A A 4"$ 5iLL ; ;@@i@@@ $..H1}.x(((A-(((v}}'':5;'..sDz:::.// / / / / / / / / /&( # *=== ? ?@@i@@@ $..H1}.x(((A-(((v}}'':5?+223:>>>233 3 3 3 3 3 3 3 3 3 AAAAAaAAA A A SQRR R !$Y [!I!I J J C   HHHHeUQY0G0GHHH I I I I{+  Fv,      rcZddlm}|||z||z ||z S)aW 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.factorialsrF)VNrFs rmonomial_countrJsE<CBBBBB 9QU  iill *YYq\\ 99rcPtdt||DS)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`. cg|] \}}||z Srrrabs rr+z monomial_mul.. 000TQ1q5000rtupler7ABs r monomial_mulrVs)" 00SAYY000 1 11rcvt||}td|Drt|SdS)a 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"K|] }|dkV dSrr)rcs rrzmonomial_div..s&  a16      rN) monomial_ldivr1rR)rTrUCs r monomial_divr\sB, aA  1   QxxtrcPtdt||DS)a 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`. cg|] \}}||z  SrrrMs rr+z!monomial_ldiv..rPrrQrSs rrZrZs), 00SAYY000 1 11rc:tfd|DS)z%Return the n-th pow of the monomial. cg|]}|zSrr)rrNr9s rr+z monomial_pow..s###11Q3###r)rR)rTr9s `r monomial_powras& ####### $ $$rcPtdt||DS)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`. c4g|]\}}t||Sr)minrMs rr+z monomial_gcd..$444A3q!99444rrQrSs r monomial_gcdrf)" 44Q444 5 55rcPtdt||DS)a1 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`. c4g|]\}}t||Sr)maxrMs rr+z monomial_lcm..&rerrQrSs r monomial_lcmrkrgrcPtdt||DS)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(K|] \}}||kVdSrrrMs rrz#monomial_divides..5s*,,$!QqAv,,,,,,r)r1r7rSs rmonomial_dividesrn(s) ,,#a)),,, , ,,rct|d}|ddD]0}t|D]\}}t|||||<1t|S)a 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) rr#N)r0 enumeraterjrRmonomsMrIrr9s r monomial_maxrt7l" VAYA ABBZ  aLL  DAqqtQ<>> from sympy.polys.monomials import monomial_min >>> monomial_min((3,4,5), (0,5,1), (6,3,9)) (0, 3, 1) rr#N)r0rprdrRrqs r monomial_minrwPrurc t|S)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 )r2)rss r monomial_degryis q66Mrc|\}}|\}}t||}|jr|||||fSdS|||zs||||fSdS)z,Division of two terms in over a ring/field. N)r\is_Fieldquo)rNrOdomaina_lma_lcb_lmb_lcmonoms rterm_divrxsJD$JD$ t $ $E    &**T4000 04  &**T4000 04rcNeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d S) MonomialOpsz6Code generator of fast monomial arithmetic functions. c||_dSr)ngens)selfrs r__init__zMonomialOps.__init__s  rc6i}t||||Sr)exec)rcodenamenss r_buildzMonomialOps._builds  T2$xrcDfdt|jDS)Ncg|]}| Srr)rrrs rr+z%MonomialOps._vars..s"@@@44#@@@r)r6r)rrs `r_varszMonomialOps._varss'@@@@U4:->->@@@@rc vd}td}|d}|d}dt||D}|t|d|d|d|z}|||S)NrVs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) rNrOc"g|] \}}|d| S) + rrMs rr+z#MonomialOps.mul..' 9 9 9daAAAqq! 9 9 9r, rrTrUABrrr7dictjoinrrrtemplaterTrUrrs rmulzMonomialOps.muls    JJsOO JJsOO 9 9c!Qii 9 9 9$DDIIaLLDIIaLLTYYWY]][[[[{{4&&&rcd}td}|d}d|D}|t|d|d|z}|||S)NrazZ def %(name)s(A, k): (%(A)s,) = A return (%(Ak)s,) rNcg|]}d|zS)z%s*kr)rrNs rr+z#MonomialOps.pow..s & & &avz & & &rr)rrTAk)rrrrr)rrrrTrrs rpowzMonomialOps.pows    JJsOO & &1 & & &$DDIIaLLTYYr]]KKKK{{4&&&rc vd}td}|d}|d}dt||D}|t|d|d|d|z}|||S)Nmonomial_mulpowzw def %(name)s(A, B, k): (%(A)s,) = A (%(B)s,) = B return (%(ABk)s,) rNrOc$g|] \}}|d|dS)rz*krrMs rr+z&MonomialOps.mulpow..s)<<<Aqqq!!!$<<.rrrrrrs rldivzMonomialOps.ldivs    JJsOO JJsOO 9 9c!Qii 9 9 9$DDIIaLLDIIaLLTYYWY]][[[[{{4&&&rc d}td}|d}|d}dt|jD}|d}|t |d|d|d|d| z}|||S) Nr\z def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B %(RAB)s return (%(R)s,) rNrOc4g|]}dt|zS)z7r%(i)s = a%(i)s - b%(i)s if r%(i)s < 0: return None)r)rrs rr+z#MonomialOps.div..s(sss[\JTTUYYYVsssrrrz )rrTrURABR)rrr6rrrr)rrrrTrUrrrs rdivzMonomialOps.divs    JJsOO JJsOOss`efjfp`q`qsss JJsOO$DDIIaLLDIIaLLhmm\_N`N`dhdmdmnodpdpqqqq{{4&&&rc vd}td}|d}|d}dt||D}|t|d|d|d|z}|||S)NrkrrNrOc .g|]\}}|d|d|d|S) if z >=  else rrMs rr+z#MonomialOps.lcm..3 N N N41a111aaaAA6 N N Nrrrrrs rlcmzMonomialOps.lcm    JJsOO JJsOO N N3q!99 N N N$DDIIaLLDIIaLLTYYWY]][[[[{{4&&&rc vd}td}|d}|d}dt||D}|t|d|d|d|z}|||S)NrfrrNrOc .g|]\}}|d|d|d|S)rz <= rrrMs rr+z#MonomialOps.gcd..rrrrrrs rgcdzMonomialOps.gcdrrN)__name__ __module__ __qualname____doc__rrrrrrrrrrrrrrrs@@ AAA ' ' ' ' ' ' ' ' ' ' ' '''' ' ' ' ' ' ' ' 'rrcxeZdZdZdZddZddZdZdZdZ d Z d Z d Z d Z d ZdZdZeZdZdZdZdS)Monomialz9Class representing a monomial, i.e. a product of powers. ) exponentsgensNct|stt||\}}t|dkrSt |ddkr(t |d}n"td|ttt||_ ||_ dS)N)rr#rzExpected a monomial got {})rr r r,r0r3keysr-formatrRmapintrr)rrrreps rrzMonomial.__init__s M&wu~~DAAAIC3xx1} Mcjjll!3!3A!6!!; MSXXZZ((+ !=!D!DU!K!KLLLs3// rc<|||p|jSr) __class__r)rrrs rrebuildzMonomial.rebuild s~~i):;;;rc*t|jSr)r,rrs r__len__zMonomial.__len__s4>"""rc*t|jSr)iterrrs r__iter__zMonomial.__iter__sDN###rc|j|Sr)r)rr>s r __getitem__zMonomial.__getitem__s~d##rcNt|jj|j|jfSr)hashrrrrrs r__hash__zMonomial.__hash__s T^,dndiHIIIrc|jr7ddt|j|jDS|jjd|jdS)N*c"g|] \}}|d| S)z**rrgenexps rr+z$Monomial.__str__..s'dddS###ss3dddr())rrr7rrrrs r__str__zMonomial.__str__sZ 9 H88ddC SWSaDbDbdddee e#~666G Grc|p|j}|std|ztdt||jDS)z3Convert a monomial instance to a SymPy expression. z5Cannot convert %s to an expression without generatorscg|] \}}||z Srrrs rr+z$Monomial.as_expr..(s JJJ83c3hJJJr)rr-rr7r)rrs ras_exprzMonomial.as_expr s\ ty PG$NPP PJJs4/H/HJJJKKrct|tr|j}n!t|ttfr|}ndS|j|kS)NF) isinstancerrrRrrotherrs r__eq__zMonomial.__eq__*sL eX & & II u~ . . II5~**rc||k Srr)rrs r__ne__zMonomial.__ne__4s5=  rct|tr|j}n&t|ttfr|}nt |t|j|Sr)rrrrRrNotImplementedErrorrrVrs r__mul__zMonomial.__mul__7s^ eX & & &II u~ . . &II% %||LCCDDDrct|tr|j}n&t|ttfr|}nt t |j|}|||St|t|r) rrrrRrrr\rr )rrrresults r __truediv__zMonomial.__truediv__As eX & & &II u~ . . &II% %dni88  =<<'' '%dHUOO<< rs FF=<<<<<<<------------666666DDDDDDDD"""""";;;;;;;;EEEEN:::B222&:2220%%%666&666& - - -22   $n'n'n'n'n'n'n'n'`|E|E|E|E|E!|E|E|E|E|Er