B [2@sddlmZmZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZmZmZdd lmZdd lmZmZdd lmZdd lmZdd lmZddlmZm Z ddZ!dddZ"ddZ#ddZ$ddZ%ddZ&dS))print_functiondivision)Add)orderedrange) expand_log)Pow)S)Dummy)LambertWexplog)root)Polyfactor)_mexpand) separatevars)collect)solve_invertcsbfdd|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)symbolr6lib/python3.7/site-packages/sympy/solvers/bivariate.py !sz!_filtered_gens..)genslistZas_numer_denomr ZOneremove)ZpolyrrrZagr)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.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) cs4g|],}r,jr|jks,js|r|qSr)Z is_SymbolrZhas)rtmp)Xrr Gsz_mostfunc..rrcs |S)N)count)x)funcrrMsz_mostfunc..)keyN)atomslenmaxrr)lhsr'r#Zftermsr)r#r'r _mostfunc+s  r.cCsd|}||\}}|js,d}||}}n|}t|j|dd\}}|rZ| }| }|||fS)a(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)) rF)as_Add)expandas_independentis_Addrcould_extract_minus_sign)argrZindZdepbar&rrr_linabQs r7cCstt|}t|t|}|s gS||d}t| tr|||||jd}|jd}t|tsfgS| jd }||7}||jkrgSt||\}}}t |||}| |}|dks||jkrgS|jd} t| |\} } } | |krgSt d} g}xdD]}t ||| t | ||| t | ||}|rJ|jsJq| | |||}t| | |}x4t|D](\}}|| |||<|||qxWqW|S)a 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)))``. rNrhs)r)rrr.r subs isinstanceargsrr7rZas_coefficientr r r Zis_realr enumerateappend)eqr&mainlogotherdfZX2Zlogtermr6Zlogargr5cZX1uZsolklr8Zsolnsir"rrr_lambertusF          4rIcs|jdd\}}| }fdd|D}|s4t|jrNtt|}t|}t|dd}t}t||\}}|||i}g} | sPt |t} | rP|jr|dkrt t|t|} n|j rP| | d} | rB| j sBfdd| tDrB|st| t| |} nt|| t|| } t t| } nt ||} | st |t} | rt|| }|jr|dkrt tt|t|} nf|j r| | d} || }|| }|r|r|d9}|d9}t|t|} t t| } | st |t}|r|jjkrt||}|jrd|dkrdt tt|t|} nB|j r| |d} || }|| }t|t|} t t| } | std |tt| S) aReturn 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) T)r/cs0g|](}|jttgks(|jr|jjkr|qSr)r'r r Zis_Powr)rr")rrrr$sz"_solve_lambert..)Zdeeprcsg|]}|jkr|qSr)r)rr")rrrr$sr9z:%s does not appear to have a solution in terms of LambertW)r1NotImplementedErrorZis_Mulrr rr rxreplacer.rIr2r:r*rr rr3rrr)rCrrZnrhsr-r8ZlamcheckrrHZsolnr@rAZdiffZmainexpZmaintermZmainpowr)rr_solve_lambertsv!            rMc sDtddd}|ddrt|}|}t}t}tt|||i||||dd}|r||i} |d| |d| |d fSd S|}|}t|} g} xT| D]:} t | |} | j } | ks| krP| | qWt| |fSfd d }g} | }| |krt |||} t |||}||||| } | d k r| || |fSg} | }| |kr@xtd D]}t ||||} t |||}||||| } | d k r0| || |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.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 rET)ZpositivefirstF)rNrrNcs.t|||}|j}|ks&|kr*dS|S)N)rr:r)rCvrDnewfree)r&yrrokwszbivariate_type..ok)r poprZas_exprbivariate_typer:rKrZ make_argsrrr>ZdegreerZcoeff_monomialr)rCr&rSkwargsrEpZ_xZ_yrvZrepsr<rQr6rRrTrBr5Zitryr)r&rSrrV4sR'   & "     rV)N)'Z __future__rrZsympy.core.addrZsympy.core.compatibilityrrZsympy.core.functionrZsympy.core.powerrZsympy.core.singletonr Zsympy.core.symbolr Z&sympy.functions.elementary.exponentialr r r Z(sympy.functions.elementary.miscellaneousrZsympy.polys.polytoolsrrrZsympy.simplify.simplifyrZsympy.simplify.radsimprZsympy.solvers.solversrrr!r.r7rIrMrVrrrrs(          &$1