B ddJ@sdZddlmZmZddlmZddlmZmZm Z m Z ddl m Z ddl mZmZddlmZddlmZmZed(d d Zd d ZddZddZddZddZddZddZddZddZddZd d!Z d"d#Z!Gd$d%d%Z"eGd&d'd'eZ#d S))z@Tools and arithmetics for monomials of distributed polynomials. )combinations_with_replacementproduct)dedent)MulSTuplesympify)ExactQuotientFailed)PicklableWithSlotsdict_from_expr)public) is_sequenceiterableNc#st|}tr~t|kr$tddkr8dg|n@tsJtdn.t|kr^tdtddDrxtdd}n:}|dkrtd dkrd}ndkrtd }d }|r,||krdS|r|dkrtjVdSt|tjg}td d|Drg}x|t||D]n}t } x|D]} d| | <q&Wx(|D] } | d kr>| | d 7<q>Wt | |kr| t |qWt|EdHng} x~t||dD]n}t } x|D]} d| | <qWx(|D] } | d kr| | d 7<qWt | |kr| t |qWt| EdHntfddt|DrRtdg} x>t|D].\} }| fddt| |d DqdWxt| D]} t | VqWdS)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 listcss|]}|dkVqdS)rN).0irrb/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/polys/monomials.py bsz itermonomials..z+min_degrees cannot contain negative numbersFzmax_degrees cannot be negativezmin_degrees cannot be negativeTcss|] }|jVqdS)N)Zis_commutative)rvariablerrrrxs)repeatc3s|]}||kVqdS)Nr)rr) max_degrees min_degreesrrrsz2min_degrees[i] must be <= max_degrees[i] for all icsg|] }|qSrr)rr)varrr sz!itermonomials..)lenr ValueErroranyrZOnelistallrdictsumvaluesappendrsetrrangezip) variablesrrnZ total_degreeZ max_degreeZ min_degreeZmonomials_list_commitemZpowersrZmonomials_list_non_commZ power_listsZmin_dZmax_dr)rrrr itermonomials svJ           (r*cCs(ddlm}|||||||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)Z(sympy.functions.combinatorial.factorialsr+)VNr+rrrmonomial_counts r.cCstddt||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`. cSsg|]\}}||qSrr)rabrrrrsz monomial_mul..)tupler&)ABrrr monomial_mulsr4cCs,t||}tdd|Dr$t|SdSdS)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`. css|]}|dkVqdS)rNr)rcrrrrszmonomial_div..N) monomial_ldivrr1)r2r3Crrr monomial_divs r8cCstddt||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`. cSsg|]\}}||qSrr)rr/r0rrrrsz!monomial_ldiv..)r1r&)r2r3rrrr6sr6cstfdd|DS)z%Return the n-th pow of the monomial. csg|] }|qSrr)rr/)r(rrrsz monomial_pow..)r1)r2r(r)r(r monomial_powsr9cCstddt||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`. cSsg|]\}}t||qSr)min)rr/r0rrrrsz monomial_gcd..)r1r&)r2r3rrr monomial_gcdsr;cCstddt||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`. cSsg|]\}}t||qSr)max)rr/r0rrrr*sz monomial_lcm..)r1r&)r2r3rrr monomial_lcmsr=cCstddt||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 css|]\}}||kVqdS)Nr)rr/r0rrrr9sz#monomial_divides..)rr&)r2r3rrrmonomial_divides,s r>cGsRt|d}x<|ddD],}x&t|D]\}}t|||||<q(WqWt|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) rrN)r enumerater<r1)monomsMr-rr(rrr monomial_max;s  rBcGsRt|d}x<|ddD],}x&t|D]\}}t|||||<q(WqWt|S)a Returns minimal 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 minimal degree for each of `x`, `y` and `z` variables:: >>> from sympy.polys.monomials import monomial_min >>> monomial_min((3,4,5), (0,5,1), (6,3,9)) (0, 3, 1) rrN)rr?r:r1)r@rAr-rr(rrr monomial_minTs  rCcCst|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 )r!)rArrr monomial_degms rDcCsf|\}}|\}}t||}|jr>|dk r8||||fSdSn$|dks^||s^||||fSdSdS)z,Division of two terms in over a ring/field. N)r8Zis_FieldZquo)r/r0domainZa_lmZa_lcZb_lmZb_lcmonomrrrterm_div|s rGc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS) MonomialOpsz6Code generator of fast monomial arithmetic functions. cCs ||_dS)N)ngens)selfrIrrr__init__szMonomialOps.__init__cCsi}t||||S)N)exec)rJcodenamensrrr_builds zMonomialOps._buildcsfddt|jDS)Ncsg|]}d|fqS)z%s%sr)rr)rNrrrsz%MonomialOps._vars..)r%rI)rJrNr)rNr_varsszMonomialOps._varscCsfd}td}|d}|d}ddt||D}|t|d|d|d|d}|||S) Nr4zs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) r/r0cSsg|]\}}d||fqS)z%s + %sr)rr/r0rrrrsz#MonomialOps.mul..z, )rNr2r3AB)rrQr&r joinrP)rJrNtemplater2r3rRrMrrrmuls  &zMonomialOps.mulcCsNd}td}|d}dd|D}|t|d|d|d}|||S)Nr9zZ def %(name)s(A, k): (%(A)s,) = A return (%(Ak)s,) r/cSsg|] }d|qS)z%s*kr)rr/rrrrsz#MonomialOps.pow..z, )rNr2Ak)rrQr rSrP)rJrNrTr2rVrMrrrpows zMonomialOps.powcCsfd}td}|d}|d}ddt||D}|t|d|d|d|d}|||S) NZmonomial_mulpowzw def %(name)s(A, B, k): (%(A)s,) = A (%(B)s,) = B return (%(ABk)s,) r/r0cSsg|]\}}d||fqS)z %s + %s*kr)rr/r0rrrrsz&MonomialOps.mulpow..z, )rNr2r3ABk)rrQr&r rSrP)rJrNrTr2r3rXrMrrrmulpows  &zMonomialOps.mulpowcCsfd}td}|d}|d}ddt||D}|t|d|d|d|d}|||S) Nr6zs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) r/r0cSsg|]\}}d||fqS)z%s - %sr)rr/r0rrrrsz$MonomialOps.ldiv..z, )rNr2r3rR)rrQr&r rSrP)rJrNrTr2r3rRrMrrrldivs  &zMonomialOps.ldivc Csxd}td}|d}|d}ddt|jD}|d}|t|d|d|d |d|d }|||S) Nr8z def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B %(RAB)s return (%(R)s,) r/r0cSsg|]}dt|dqS)z7r%(i)s = a%(i)s - b%(i)s if r%(i)s < 0: return None)r)r )rrrrrrsz#MonomialOps.div..rz, z )rNr2r3RABR)rrQr%rIr rSrP)rJrNrTr2r3r\r]rMrrrdivs   .zMonomialOps.divcCsfd}td}|d}|d}ddt||D}|t|d|d|d|d}|||S) Nr=zs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) r/r0cSs g|]\}}d||||fqS)z%s if %s >= %s else %sr)rr/r0rrrrsz#MonomialOps.lcm..z, )rNr2r3rR)rrQr&r rSrP)rJrNrTr2r3rRrMrrrlcms  &zMonomialOps.lcmcCsfd}td}|d}|d}ddt||D}|t|d|d|d|d}|||S) Nr;zs def %(name)s(A, B): (%(A)s,) = A (%(B)s,) = B return (%(AB)s,) r/r0cSs g|]\}}d||||fqS)z%s if %s <= %s else %sr)rr/r0rrrrsz#MonomialOps.gcd..z, )rNr2r3rR)rrQr&r rSrP)rJrNrTr2r3rRrMrrrgcds  &zMonomialOps.gcdN)__name__ __module__ __qualname____doc__rKrPrQrUrWrYrZr^r_r`rrrrrHs rHc@seZdZdZdZd"ddZd#ddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZeZddZddZd d!ZdS)$Monomialz9Class representing a monomial, i.e. a product of powers. ) exponentsgensNcCsvt|s\tt||d\}}t|dkrNt|ddkrNt|d}ntd|t t t ||_ ||_ dS)N)rgrrzExpected a monomial got {})rr rrrr"keysrformatr1mapintrfrg)rJrFrgreprrrrKs zMonomial.__init__cCs|||p|jS)N) __class__rg)rJrfrgrrrrebuildszMonomial.rebuildcCs t|jS)N)rrf)rJrrr__len__szMonomial.__len__cCs t|jS)N)iterrf)rJrrr__iter__szMonomial.__iter__cCs |j|S)N)rf)rJr)rrr __getitem__szMonomial.__getitem__cCst|jj|j|jfS)N)hashrmrarfrg)rJrrr__hash__szMonomial.__hash__cCs:|jr$dddt|j|jDSd|jj|jfSdS)N*cSsg|]\}}d||fqS)z%s**%sr)rgenexprrrr sz$Monomial.__str__..z%s(%s))rgrSr&rfrmra)rJrrr__str__szMonomial.__str__cGs4|p|j}|std|tddt||jDS)z3Convert a monomial instance to a SymPy expression. z5Cannot convert %s to an expression without generatorscSsg|]\}}||qSrr)rrvrwrrrr,sz$Monomial.as_expr..)rgrrr&rf)rJrgrrras_expr$s   zMonomial.as_exprcCs4t|tr|j}nt|ttfr&|}ndS|j|kS)NF) isinstancererfr1r)rJotherrfrrr__eq__.s  zMonomial.__eq__cCs ||k S)Nr)rJr{rrr__ne__8szMonomial.__ne__cCs<t|tr|j}nt|ttfr&|}nt|t|j|S)N)rzrerfr1rNotImplementedErrorrnr4)rJr{rfrrr__mul__;s  zMonomial.__mul__cCsZt|tr|j}nt|ttfr&|}ntt|j|}|dk rH||St|t|dS)N) rzrerfr1rr~r8rnr )rJr{rfresultrrr __truediv__Es   zMonomial.__truediv__cCsht|}|s |dgt|S|dkrX|j}xtd|D]}t||j}q:W||Std|dS)Nrrz'a non-negative integer expected, got %s)rkrnrrfr%r4r)rJr{r(rfrrrr__pow__Vs zMonomial.__pow__cCsDt|tr|j}n t|ttfr&|}n td||t|j|S)z&Greatest common divisor of monomials. z.an instance of Monomial class expected, got %s)rzrerfr1r TypeErrorrnr;)rJr{rfrrrr`es  z Monomial.gcdcCsDt|tr|j}n t|ttfr&|}n td||t|j|S)z$Least common multiple of monomials. z.an instance of Monomial class expected, got %s)rzrerfr1rrrnr=)rJr{rfrrrr_qs  z Monomial.lcm)N)N)rarbrcrd __slots__rKrnrorqrrrtrxryr|r}rr __floordiv__rr`r_rrrrres$     re)N)$rd itertoolsrrtextwraprZ sympy.corerrrrZsympy.polys.polyerrorsr Zsympy.polys.polyutilsr r Zsympy.utilitiesr Zsympy.utilities.iterablesr rr*r.r4r8r6r9r;r=r>rBrCrDrGrHrerrrrs2     !p