EdEddlmZddlmZddlmZmZddlmZddl m Z ddl m Z ddl mZddlmZmZmZdd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZddlm Z m!Z!ddl"m#Z#dZ$ddZ%dZ&dZ'dZ(dddZ)dS))Add) factor_terms) expand_log_mexpand)Pow)S)ordered)Dummy)LambertWexplog)root)roots)Polyfactor) separatevars)collect)powsimp)solve_invert)uniqcfd|jD}t|D]L}d|z }||vrA||vr=|dtjur|}||M|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)} c&h|] }|jv |S free_symbols).0gsymbols 7lib/python3.11/site-packages/sympy/solvers/bivariate.py z!_filtered_gens..%s% = = =!Fan$< =A = = =)genslistas_numer_denomrOneremove)polyrr$rags ` r _filtered_gensr+s$ > = = =ty = = =D $ZZ qS 9 t   ""1%QU2  KKNNN Kr"Ncfd|D}t|dkr|dS|r.ttt |fdSdS)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) cpg|]2}r,jr |jvsj|0|3Sr) is_Symbolrhas)rtmpXs r z_mostfunc..Jsb)))cQ) )S--) K)GGAJJ)c)))r"r#rc.|SN)count)xfuncs r z_mostfunc..Ps r")keyN)atomslenmaxr%r )lhsr7r1ftermss `` r _mostfuncr?/s6))))SYYt__)))F 6{{aGay G4((.E.E.E.EFFFF 4r"czt|}||\}}|jr&|jrt ||\}}}||z||z|fS|jsd}||}}n)|}t ||d\}}|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)) rFas_Add)rexpandas_independentis_Mulis_Add_linabrcould_extract_minus_sign)argrinddepabr6s r rGrGTs( szz|| $ $C!!&))HC zcjf%%1a1uc!eQ :F C1 C  //u/EE1!!## B B a7Nr"ctt|}t|t|}|sgS||d}t | tr\||z ||jd}|jd}t |tsgS| jd }||z }||jvrgSt||\}}t||z |}| | |jvrgS|jd}t||\}} | |krgStdt| z |} ddg} g} |z|zz z z \} }|\}}t| |z }td}fdt!||z|z |D}|D]R}| D]M}t%||}|r|js| z z |zz| fd| DNS| 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)))``. rNrhstc&g|] }zz |zSrr)rrQrLrMds r r2z_lambert..s% 9 9 9!AqsGAI 9 9 9r"c3DK|]}|VdSr4)subs)rxurOus r z_lambert..s/992rwwq#999999r")rrr?r rU isinstanceargsrrGras_coefficientr rr& as_coeff_Mulr rkeysr is_realextend)eqr6mainlogotherfX2logtermlogargcX1xusolnslambert_real_branchessolnumdenperQrZrIkwrLrMrSrOrWs @@@@@r _lambertrrys *R.. ! !BC##G  GGGQ  E5&#5j  w Q 8 8,q/'3'' I&q!! e "" eQHAq"b5j'**Gw''AA' \!_Ffa  HAq" Rx  e ABFAG G C1QqS! A --//HC     FAs CG A c A 9 9 9 9 9 9uQTAXq116688 9 9 9D::& : :Aa  A  "Q$!A#q.C JJ99999999 9 9 9 9  : Jr"cp fd}|d\}}| }fdD}|st|js|jrQt dij|fdfd}|jr|r|d}||z } ||z } | jse| rc| tj tj s9tt| t| z } || Snd|jr]|r[tt|d }t|}|r|jr||z } || S|i}tt!|d }t } t#|| z \} }| | |i}g}|st%|t}|r|jr4|dkr.t't|t|z }n|jr||d}|r|jsfd |t*Drh|s#t|t||z z }n%t||z t||z z }t't|}nt'||z }|st%|t,}|rt/||}|jrA|dkr;t'tt|t|z }n|jr||d}||z }||z }|r|r |d z}|d z}t|t|z }t't|}|st%|t*}|rɉ|jjvrt/||}|jrA|dkr;t'tt|t|z }nc|jr\||d}||z }||z }t|t|z }t't|}|std |zt5t7|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) cfddD\}}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. cDg|]}|ziSr)xreplace)rsgnexprrrQs r r2zC_solve_lambert.._solve_even_degree_expr.. s:???/2DMM1c&j/ * *???r")rPr#)_solve_lambertr_r%r)rxrQrnlhsplhssolsr$s``` r _solve_even_degree_exprz/_solve_lambert.._solve_even_degree_exprsT??????6=??? ddFD11 4< < KKtVT:: ; ; ; DJJr"TrAchg|].}|jttfvs|j|jjv,|/Sr)r7r r is_Powrrr0rs r r2z"_solve_lambert..s]BBBHc *BB &#'*> >BBBBr"rQc@|jo|jko |jjSr4)rbaser is_even)irs r r8z _solve_lambert..(s"?QVv-?!%-r"c|jzSr4)r )rrQs r r8z _solve_lambert..*s15r"r)force)deepc&g|] }|jv |Srrrs r r2z"_solve_lambert..\s7373737 #!S%5537373737r"rPz:%s does not appear to have a solution in terms of LambertW)rQ)rDNotImplementedErrorrFrEr assumptions0replacer/rUrComplexInfinityNaNrr rvrrrr?rrr:rr rrHrr%r )rcrr$r}nrhsr=rOlamcheckt_indept_term_rhsr`rrsolnrarbdiffmainexpmaintermmainpowrQs `` @r ryrysD4 4 4 4 4 l   55ID# %CBBBBtBBBH $!### z(SZ(  - -, - -kk @ @ @ @     : >#''!** >hhq!nnG7]F=D= >T >JJq0!%88 >F c$ii 788..r1f=== Z >C >SXXT222Cc((Cwwqzz >cj >3Y..r1f===llAv;'' &4((( ) )C A S1Wf % %FAs **aX  C D 7Cf--  7z 7cQh 7C3s88 3V<< 7!,, 7 737373737',{{3'7'7373737 7C"5zzC ,<,<<"3;//#cEk2B2BB#Jt$4$4f==DD$C#Iv66D :Cf--  :#w''Cz :cQh : 3s88c#hh+> ? ?HH :!,,;Ek55770022NH2IC8}}s3xx/ 4 0 0&99  :Cf--  :v!99 :#w''Cz :cQh : 3s88c#hh+> ? ?HH :!,,;Ek8}}s3xx/ 4 0 0&99 %!# "##$%% %   r"Tfirstc tdd}|rt|}|}t}t}tt|||i||||d}|rC||i} |d| |d| |dfSd S|}|}t j|} g} | D]N} t| |z } | j } | vs| vrn%| | Ozt | |fSfd }g} | }| |krrt| |z|} t| |z|}||||zz | z } | | z|zz| |fSg} | }| |krtdD]}t| |z|zz|} t| |z|}||||zz | z z } | | zz|zz| |fcScd Sd 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 rWT)positiveFrrr#Ncpt|||}|j}|vs|vrdn|Sr4)rrUr)rcvrgnewfreer6ys r okzbivariate_type..oks@qvva||$$T 8Q$Y8ttS8r")r ras_exprbivariate_typerUrvr make_argsrrappenddegreercoeff_monomialrange)rcr6rrrWrn_x_yrvrepsrZrrLrrrSrMitrys `` r rrs?N cD!!!A  AqMM IIKK WW WW DB2!7!7R@@"bPU V V V  E2q>Da5>>$''A)=)=r!uD D A A = % %D C !! QVVAqs^^ $ $~ 9 T   E 1 sCIq  999999 C  Axx{{a% !!!Q$'' + + !!!Q$'' + +bAAaC{##  %Q319c1$ $ C  Axx{{a!HH  DQ%%ad1a4i00!44AQ%%ad++Q//A"QA!GQ;q=))C +s1uqs{C****aDAqq  r"r4)*sympy.core.addrsympy.core.exprtoolsrsympy.core.functionrrsympy.core.powerrsympy.core.singletonrsympy.core.sortingr sympy.core.symbolr &sympy.functions.elementary.exponentialr r r (sympy.functions.elementary.miscellaneousrsympy.polys.polyrootsrsympy.polys.polytoolsrrsympy.simplify.simplifyrsympy.simplify.radsimprrsympy.solvers.solversrrsympy.utilities.iterablesrr+r?rGrrryrrr"r rs------44444444 """"""&&&&&&######GGGGGGGGGG999999''''''........000000******++++++00000000******8""""J"""JEEEP]]]@&*\\\\\\\r"