ó ¡¼™\c@ sAddlmZmZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZmZmZdd lmZdd lmZmZdd lmZdd lmZdd lmZddlmZm Z d„Z!dd„Z#d„Z$d„Z%d„Z&d„Z'dS(iÿÿÿÿ(tprint_functiontdivision(tAdd(torderedtrange(t expand_log(tPow(tS(tDummy(tLambertWtexptlog(troot(tPolytfactor(t_mexpand(t separatevars(tcollect(tsolvet_invertc sˆ‡fd†|jDƒ}xht|ƒD]Z}d|}||kr&||kr&|jƒdtjk rp|}n|j|ƒq&q&W|S(sªprocess 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)} c s%h|]}ˆ|jkr|’qS((t free_symbols(t.0tg(tsymbol(s6lib/python2.7/site-packages/sympy/solvers/bivariate.pys !s i(tgenstlisttas_numer_denomRtOnetremove(tpolyRRRtag((Rs6lib/python2.7/site-packages/sympy/solvers/bivariate.pyt_filtered_genss  c s£g|jˆƒD]D}| sN|jr5||jksN|j r|j|ƒr|^q}t|ƒdkrt|dS|rŸttt|ƒƒd‡fd†ƒSdS(s~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.functions.elementary.exponential import exp >>> from sympy.utilities.pytest import raises >>> 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) iitkeyc s |jˆƒS(N(tcount(tx(tfunc(s6lib/python2.7/site-packages/sympy/solvers/bivariate.pytMtN( tatomst is_SymbolRthastlentmaxRRtNone(tlhsR#tXttmptfterms((R#s6lib/python2.7/site-packages/sympy/solvers/bivariate.pyt _mostfunc+s%%cC s‘|jƒ}|j|ƒ\}}|js@d}||}}n'|}t|ƒj|dtƒ\}}|jƒr„| }| }n|||fS(s(Return ``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.functions.elementary.exponential import exp >>> from sympy.solvers.bivariate import _linab >>> from sympy.abc import x, y >>> from sympy import 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)) itas_Add(texpandtas_independenttis_AddRtFalsetcould_extract_minus_sign(targRtindtdeptbtaR"((s6lib/python2.7/site-packages/sympy/solvers/bivariate.pyt_linabQs  !  cC s7tt|ƒƒ}t|t|ƒ}|s.gS|j|dƒ}t| tƒr©||j||jdƒ}|jd}t|tƒsgS| jd }||7}n||jkr¼gSt||ƒ\}}}t |||ƒ}|j |ƒ}|dks||jkrgS|jd} t| |ƒ\} } } | |krJgSt dƒ} g}xÔddgD]Æ}t ||| t| ||| ƒt| |ƒ|ƒ}|rÁ|j rÁqin| | |||}t| | |ƒ}xAt|ƒD]3\}}|j| |ƒ||<|j||ƒqøWqiW|S(s 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 if possible: ``x = g^-1(-c/b + (a/d)*W(d/(a*b)*exp(c*d/a/b)*exp(-f/a)))``. itrhsiÿÿÿÿN(RRR0R tsubst isinstancetargsRR<Rtas_coefficientR+RR R tis_realRt enumeratetappend(teqR"tmainlogtothertdtftX2tlogtermR;tlogargR:tctX1tutsoltktlR=tsolnstiR.((s6lib/python2.7/site-packages/sympy/solvers/bivariate.pyt_lambertusF     <cC s!|j|dtƒ\}}| }g|D]<}|jttgks_|jr)||jjkr)|^q)}|s}tƒ‚n|jr§t t|ƒƒ}t|ƒ}nt |dtƒ}t ƒ}t |||ƒ\} }| j i||6ƒ}g} | st|t|ƒ} | r|jrL|dkrLtt|ƒt|ƒ|ƒ} q|jr|j| dƒ} | r| j rg| jtƒD]}||jkr‡|^q‡r|sËt| ƒt| |ƒ} nt|| ƒt|| ƒ} tt | ƒ|ƒ} qt|||ƒ} qqn| st|t|ƒ}|rt||ƒ}|jr‡|dkr‡tt t|ƒt|ƒƒ|ƒ} q|jr|j|dƒ} || }|| }|jƒrå|jƒrå|d9}|d9}nt|ƒt|ƒ} tt | ƒ|ƒ} qqn| søt|t|ƒ}|rø||jjkrøt||ƒ}|jr•|dkr•tt t|ƒt|ƒƒ|ƒ} qõ|jrõ|j|dƒ} || }|| }t|ƒt|ƒ} tt | ƒ|ƒ} qõqøn| std|ƒ‚ntt| ƒƒS(sReturn solution to ``f`` if it is a Lambert-type expression else raise NotImplementedError. The equality, ``f(x, a..f) = a*log(b*X + c) + d*X - f = 0`` has the solution, `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 [0, 1] then log(B) + log(log(B)) = log(log(R)) 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(B) + a*log(b*log(B) + c) = log(R) X = log(B); d=1, f=log(R) 1b) if a*log(b*B + c) + d*B = R then X = B, f = R 2a) if (b*B + c)*exp(d*B + g) = R then log(b*B + c) + d*B + g = log(R) a = 1, f = log(R) - g, X = B 2b) if -b*B + g*exp(d*B + h) = c then log(g) + d*B + h - log(b*B + c) = 0 a = -1, f = -h - log(g), X = B 3) if d*p**(a*B + g) - b*B = c then log(d) + (a*B + g)*log(p) - log(c + b*B) = 0 a = -1, d = a*log(p), f = -log(d) - g*log(p) R1tdeepiiÿÿÿÿs:%s does not appear to have a solution in terms of LambertW(R3tTrueR#R R tis_PowRtNotImplementedErrortis_MulRRRRtxreplaceR0RUR4R>R&RRR6RR(RIRRtnrhsR,R=R.tlamchecktrRTtsolnRFRGtdifftmainexptmaintermtmainpow((s6lib/python2.7/site-packages/sympy/solvers/bivariate.pyt_solve_lambert¦s|! '   " (       (    c stddtƒ}|jdtƒrØt|ˆˆƒ}|jƒ}tƒ}tƒ}tt|ji|ˆ6|ˆ6ƒ||ƒ||dtƒ}|rÔiˆ|6ˆ|6} |dj| ƒ|dj| ƒ|dfSdS|}|jƒ}t j |jƒƒ} g} xs| D]T} t | jˆ|ˆƒƒ} | j } ˆ| ksOˆ| krSPn| j | ƒq Wˆˆt | Œ|fS‡‡fd†}g} |jˆƒ}|jˆƒ|kr5t|jˆ|ƒ|ƒ} t|jˆ|ƒ|ƒ}||ˆ||ˆ| ƒ} | dk r5| ˆ|ˆ| |fSng} |jˆƒ}|jˆƒ|krx¯tdƒD]ž}t|jˆ|ˆ|ƒ|ƒ} t|jˆ|ƒ|ƒ}||ˆ||ˆ| ˆƒ} | dk rý| ˆˆ|ˆ| |fSˆˆ‰‰qlWndS( s÷Given 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.solvers.solvers 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 ROtpositivetfirstiiiNc sAt|j||ƒƒ}|j}ˆ|ks9ˆ|kr=dS|S(N(RR>RR+(RItvRMtnewtfree(R"ty(s6lib/python2.7/site-packages/sympy/solvers/bivariate.pytokws (RRWtpopR tas_exprtbivariate_typeR>R5R[Rt make_argsRRRDtdegreeR tcoeff_monomialR+R(RIR"RjtkwargsROtpt_xt_ytrvtrepsR@RhR;RiRkRHR:titry((R"Rjs6lib/python2.7/site-packages/sympy/solvers/bivariate.pyRn4sR'   ;+    $" N((t __future__RRtsympy.core.addRtsympy.core.compatibilityRRtsympy.core.functionRtsympy.core.powerRtsympy.core.singletonRtsympy.core.symbolRt&sympy.functions.elementary.exponentialR R R t(sympy.functions.elementary.miscellaneousR tsympy.polys.polytoolsR RRtsympy.simplify.simplifyRtsympy.simplify.radsimpRtsympy.solvers.solversRRRR+R0R<RURdRn(((s6lib/python2.7/site-packages/sympy/solvers/bivariate.pyts&  & $ 1 Ž