B edGE@sddlmZddlmZddlmZmZddlmZddl m Z ddl m Z ddl mZddlmZmZmZdd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZddlm Z m!Z!ddl"m#Z#ddZ$d ddZ%ddZ&ddZ'ddZ(ddddZ)dS)!)Add) factor_terms) expand_log_mexpand)Pow)S)ordered)Dummy)LambertWexplog)root)roots)Polyfactor) separatevars)collect)powsimp)solve_invert)uniqcsbfdd|jD}xHt|D]<}d|}||kr||kr|dtjk rP|}||qW|S)aprocess the generators of ``poly``, returning the set of generators that have ``symbol``. If there are two generators that are inverses of each other, prefer the one that has no denominator. Examples ======== >>> from sympy.solvers.bivariate import _filtered_gens >>> from sympy import Poly, exp >>> from sympy.abc import x >>> _filtered_gens(Poly(x + 1/x + exp(x)), x) {x, exp(x)} csh|]}|jkr|qS) free_symbols).0g)symbolrd/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/solvers/bivariate.py "sz!_filtered_gens..)genslistas_numer_denomrZOneremove)Zpolyrrragr)rr_filtered_genssr$NcsPfdd|D}t|dkr,|dS|rLttt|fdddSdS) a+Returns the term in lhs which contains the most of the func-type things e.g. log(log(x)) wins over log(x) if both terms appear. ``func`` can be a function (exp, log, etc...) or any other SymPy object, like Pow. If ``X`` is not ``None``, then the function returns the term composed with the most ``func`` having the specified variable. Examples ======== >>> from sympy.solvers.bivariate import _mostfunc >>> from sympy import exp >>> from sympy.abc import x, y >>> _mostfunc(exp(x) + exp(exp(x) + 2), exp) exp(exp(x) + 2) >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp) exp(exp(y) + 2) >>> _mostfunc(exp(x) + exp(exp(y) + 2), exp, x) exp(x) >>> _mostfunc(x, exp, x) is None True >>> _mostfunc(exp(x) + exp(x*y), exp, x) exp(x) cs4g|],}r,jr|jks,js|r|qSr)Z is_Symbolrhas)rtmp)Xrr Gsz_mostfunc..rrcs |S)N)count)x)funcrrMz_mostfunc..)keyN)atomslenmaxr r)lhsr+r'Zftermsr)r'r+r _mostfunc,s  r3cCst|}||\}}|jrH|jrHt||\}}}|||||fS|js^d}||}}n|}t|j|dd\}}|r| }| }|||fS)aReturn ``a, b, X`` assuming ``arg`` can be written as ``a*X + b`` where ``X`` is a symbol-dependent factor and ``a`` and ``b`` are independent of ``symbol``. Examples ======== >>> from sympy.solvers.bivariate import _linab >>> from sympy.abc import x, y >>> from sympy import exp, S >>> _linab(S(2), x) (2, 0, 1) >>> _linab(2*x, x) (2, 0, x) >>> _linab(y + y*x + 2*x, x) (y + 2, y, x) >>> _linab(3 + 2*exp(x), x) (2, 3, exp(x)) rF)as_Add)rexpandas_independentis_Mulis_Add_linabrcould_extract_minus_sign)argrinddepabr*rrrr9Qs   r9c stt|}t|t|}|s gS||d}t| tr|||||jd}|jd}t|tsfgS| jd }||7}||jkrgSt||\}}t |||}| |dks|jkrgS|jd}t||\}} | |krgSt d} t | | |} ddg} g} || \}}|\}}t||}t d}fddt||||D}xr|D]j}xb| D]Z}t||}|r|jsq| |}x | D]}| || |qWqWq~W| S)z Given an expression assumed to be in the form ``F(X, a..f) = a*log(b*X + c) + d*X + f = 0`` where X = g(x) and x = g^-1(X), return the Lambert solution, ``x = g^-1(-c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(-f/a)))``. rNrhstcsg|]}|qSrr)rrB)r>r?drrr(sz_lambert..)rrr3r subs isinstanceargsrr9rZas_coefficientr rr!Z as_coeff_Mulr rkeysr Zis_realappend)eqr*mainlogotherfZX2ZlogtermZlogargcZX1uZxusolnsZlambert_real_branchesZsolnumZdenperBrFr;kwr@Zxur)r>r?rCr_lambertvsR             (    $rTcsfdd}|jdd\}}| }fddD}|s@t|jsN|jr:tdj|fdd fd d }|jr|r|d }||} ||} | js| r| t j t j st t | t | } || SnN|jr,|r,t t |dd }t |}|r,|jr,||} || S|i}tt|dd }t} t|| \} }| | |i}g}|sDt|t }|rD|jr|d krtt |t |}n|jrD||d }|r6|js6fdd|tDr6|st |t ||}nt ||t ||}tt |}nt||}|st|t}|rt||}|jr|d krtt t |t |}nf|jr||d }||}||}|r|r|d9}|d9}t |t |}tt |}|st|t}|r|jjkrt||}|jrX|d krXtt t |t |}nB|jr||d }||}||}t |t |}tt |}|std|tt|S)aReturn solution to ``f`` if it is a Lambert-type expression else raise NotImplementedError. For ``f(X, a..f) = a*log(b*X + c) + d*X - f = 0`` the solution for ``X`` is ``X = -c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(f/a))``. There are a variety of forms for `f(X, a..f)` as enumerated below: 1a1) if B**B = R for R not in [0, 1] (since those cases would already be solved before getting here) then log of both sides gives log(B) + log(log(B)) = log(log(R)) and X = log(B), a = 1, b = 1, c = 0, d = 1, f = log(log(R)) 1a2) if B*(b*log(B) + c)**a = R then log of both sides gives log(B) + a*log(b*log(B) + c) = log(R) and X = log(B), d=1, f=log(R) 1b) if a*log(b*B + c) + d*B = R and X = B, f = R 2a) if (b*B + c)*exp(d*B + g) = R then log of both sides gives log(b*B + c) + d*B + g = log(R) and X = B, a = 1, f = log(R) - g 2b) if g*exp(d*B + h) - b*B = c then the log form is log(g) + d*B + h - log(b*B + c) = 0 and X = B, a = -1, f = -h - log(g) 3) if d*p**(a*B + g) - b*B = c then the log form is log(d) + (a*B + g)*log(p) - log(b*B + c) = 0 and X = B, a = -1, d = a*log(p), f = -log(d) - g*log(p) csLfdddD\}}t|}||kr@|t|tt|S)aReturn the unique solutions of equations derived from ``expr`` by replacing ``t`` with ``+/- symbol``. Parameters ========== expr : Expr The expression which includes a dummy variable t to be replaced with +symbol and -symbol. symbol : Symbol The symbol for which a solution is being sought. Returns ======= List of unique solution of the two equations generated by replacing ``t`` with positive and negative ``symbol``. Notes ===== If ``expr = 2*log(t) + x/2` then solutions for ``2*log(x) + x/2 = 0`` and ``2*log(-x) + x/2 = 0`` are returned by this function. Though this may seem counter-intuitive, one must note that the ``expr`` being solved here has been derived from a different expression. For an expression like ``eq = x**2*g(x) = 1``, if we take the log of both sides we obtain ``log(x**2) + log(g(x)) = 0``. If x is positive then this simplifies to ``2*log(x) + log(g(x)) = 0``; the Lambert-solving routines will return solutions for this, but we must also consider the solutions for ``2*log(-x) + log(g(x))`` since those must also be a solution of ``eq`` which has the same value when the ``x`` in ``x**2`` is negated. If `g(x)` does not have even powers of symbol then we do not want to replace the ``x`` there with ``-x``. So the role of the ``t`` in the expression received by this function is to mark where ``+/-x`` should be inserted before obtaining the Lambert solutions. csg|]}|iqSr)xreplace)rZsgn)exprrrBrrr( szC_solve_lambert.._solve_even_degree_expr..)rAr)_solve_lambertextendr r)rVrBrZnlhsZplhsZsols)r)rVrrBr_solve_even_degree_exprs + z/_solve_lambert.._solve_even_degree_exprT)r4cs0g|](}|jttgks(|jr|jjkr|qSr)r+r r is_Powr)rr&)rrrr(sz"_solve_lambert..rBcs|jo|jko|jjS)N)rZbaser Zis_even)i)rrrr,&sz _solve_lambert..cs |jS)N)r )r\)rBrrr,(sr)force)deepcsg|]}|jkr|qSr)r)rr&)rrrr([srAz:%s does not appear to have a solution in terms of LambertW)rB)r6NotImplementedErrorr8r7r Z assumptions0replacer%rDrZComplexInfinityNaNrr rUrrrr3rTr/rr rr:rr r)rLrrrYZnrhsr2r@ZlamcheckZt_indepZt_termZ_rhsrIrr\ZsolnrJrKdiffZmainexpZmaintermZmainpowr)rrrBrrWs" 6                rWT)firstcs<tddd}|rt|}|}t}t}tt|||i||||dd}|r||i} |d| |d| |dfSd S|}|}t|} g} xT| D]:} t| |} | j } | ksވ| krP| | qWt| |fSfd d }g} | }| |krt | ||} t | ||}||||| } | d k r| || |fSg} | }| |kr8xtdD]}t | |||} t | ||}||||| } | d k r(| || |fSqWd S) aGiven an expression, f, 3 tests will be done to see what type of composite bivariate it might be, options for u(x, y) are:: x*y x+y x*y+x x*y+y If it matches one of these types, ``u(x, y)``, ``P(u)`` and dummy variable ``u`` will be returned. Solving ``P(u)`` for ``u`` and equating the solutions to ``u(x, y)`` and then solving for ``x`` or ``y`` is equivalent to solving the original expression for ``x`` or ``y``. If ``x`` and ``y`` represent two functions in the same variable, e.g. ``x = g(t)`` and ``y = h(t)``, then if ``u(x, y) - p`` can be solved for ``t`` then these represent the solutions to ``P(u) = 0`` when ``p`` are the solutions of ``P(u) = 0``. Only positive values of ``u`` are considered. Examples ======== >>> from sympy import solve >>> from sympy.solvers.bivariate import bivariate_type >>> from sympy.abc import x, y >>> eq = (x**2 - 3).subs(x, x + y) >>> bivariate_type(eq, x, y) (x + y, _u**2 - 3, _u) >>> uxy, pu, u = _ >>> usol = solve(pu, u); usol [sqrt(3)] >>> [solve(uxy - s) for s in solve(pu, u)] [[{x: -y + sqrt(3)}]] >>> all(eq.subs(s).equals(0) for sol in _ for s in sol) True rNT)ZpositiveF)rdrrNcs.t|||}|j}|ks&|kr*dS|S)N)rrDr)rLvrMnewfree)r*yrrokszbivariate_type..ok)r rZas_exprbivariate_typerDrUrZ make_argsrrrHZdegreer Zcoeff_monomialrange)rLr*rirdrNrPZ_xZ_yrvZrepsrFrgr>rhrjrCr?Zitryr)r*rirrksR'  & "     rk)N)*Zsympy.core.addrZsympy.core.exprtoolsrZsympy.core.functionrrZsympy.core.powerrZsympy.core.singletonrZsympy.core.sortingrZsympy.core.symbolr Z&sympy.functions.elementary.exponentialr r r Z(sympy.functions.elementary.miscellaneousr Zsympy.polys.polyrootsrZsympy.polys.polytoolsrrZsympy.simplify.simplifyrZsympy.simplify.radsimprrZsympy.solvers.solversrrZsympy.utilities.iterablesrr$r3r9rTrWrkrrrrs,             %%Ia