a >> from sympy import re, im, I, E, symbols >>> x, y = symbols('x y', real=True) >>> re(2*E) 2*E >>> re(2*I + 17) 17 >>> re(2*I) 0 >>> re(im(x) + x*I + 2) 2 >>> re(5 + I + 2) 7 Parameters ========== arg : Expr Real or complex expression. Returns ======= expr : Expr Real part of expression. See Also ======== im argsTc CsJ|tjurtjS|tjur tjS|jr*|S|jslzre.eval..)rNaNComplexInfinityis_extended_real is_imaginary ImaginaryUnitZero is_Matrix as_real_imag is_Function isinstance conjugater r!r make_argsas_coefficientappendhaslenim clsargincludedZrevertedexcludedr!ZtermZcoeffZ real_imagabcr)r)r*evalGs8         zre.evalcKs |tjfS)zF Returns the real number with a zero imaginary part. rr2selfdeephintsr)r)r*r4pszre.as_real_imagcCs`|js|jdjr*tt|jd|ddS|js<|jdjr\tj tt|jd|ddSdSNrTevaluate)r/r!r r r0rr1r=rIxr)r)r*_eval_derivativews zre._eval_derivativecKs|jdtjt|jdSNr)r!rr1r=rIr@kwargsr)r)r*_eval_rewrite_as_im~szre._eval_rewrite_as_imcCs |jdjSrRr!Z is_algebraicrIr)r)r*_eval_is_algebraicszre._eval_is_algebraiccCst|jdj|jdjgSrR)rr!r0is_zerorWr)r)r* _eval_is_zeroszre._eval_is_zerocCs|jdjrdSdSNrTr! is_finiterWr)r)r*_eval_is_finites zre._eval_is_finitecCs|jdjrdSdSr[r\rWr)r)r*_eval_is_complexs zre._eval_is_complexN)T)__name__ __module__ __qualname____doc__tTupler __annotations__r/ unbranched_singularities classmethodrFr4rQrUrXrZr^r_r)r)r)r*r s )  ( r c@speZdZUdZeeed<dZdZdZ e ddZ dddZ dd Z d d Zd d ZddZddZddZdS)r=a Returns imaginary part of expression. This function performs only elementary analysis and so it will fail to decompose properly more complicated expressions. If completely simplified result is needed then use ``Basic.as_real_imag()`` or perform complex expansion on instance of this function. Examples ======== >>> from sympy import re, im, E, I >>> from sympy.abc import x, y >>> im(2*E) 0 >>> im(2*I + 17) 2 >>> im(x*I) re(x) >>> im(re(x) + y) im(y) >>> im(2 + 3*I) 3 Parameters ========== arg : Expr Real or complex expression. Returns ======= expr : Expr Imaginary part of expression. See Also ======== re r!Tc CsT|tjurtjS|tjur tjS|jr,tjS|js>tj|jrJtj |S|jr\|dS|j r|t |t r|t |j d Sggg}}}t|}|D]t}|tj}|dur|js||n ||q|tjs|js|j|d}|r||dq||qt|t|krPdd|||fD\} } } || t| | SdS)Nrr"css|]}t|VqdSr$r%r&r)r)r*r+r,zim.eval..)rr-r.r/r2r0r1r3r4r5r6r7r=r!rr8r9r:r;r<r r>r)r)r*rFs8          zim.evalcKs |tjfS)zC Return the imaginary part with a zero real part. rGrHr)r)r*r4szim.as_real_imagcCs`|js|jdjr*tt|jd|ddS|js<|jdjr\tj tt|jd|ddSdSrL)r/r!r=r r0rr1r rOr)r)r*rQs zim._eval_derivativecKs tj |jdt|jdSrR)rr1r!r rSr)r)r*_eval_rewrite_as_reszim._eval_rewrite_as_recCs |jdjSrRrVrWr)r)r*rXszim._eval_is_algebraiccCs |jdjSrRr!r/rWr)r)r*rZszim._eval_is_zerocCs|jdjrdSdSr[r\rWr)r)r*r^s zim._eval_is_finitecCs|jdjrdSdSr[r\rWr)r)r*r_s zim._eval_is_complexN)T)r`rarbrcrdr rer/rfrgrhrFr4rQrjrXrZr^r_r)r)r)r*r=s )  ' r=cseZdZdZdZdZfddZeddZddZ d d Z d d Z d dZ ddZ ddZddZddZddZd$ddZddZddZd d!Zd"d#ZZS)%signa Returns the complex sign of an expression: Explanation =========== If the expression is real the sign will be: * $1$ if expression is positive * $0$ if expression is equal to zero * $-1$ if expression is negative If the expression is imaginary the sign will be: * $I$ if im(expression) is positive * $-I$ if im(expression) is negative Otherwise an unevaluated expression will be returned. When evaluated, the result (in general) will be ``cos(arg(expr)) + I*sin(arg(expr))``. Examples ======== >>> from sympy import sign, I >>> sign(-1) -1 >>> sign(0) 0 >>> sign(-3*I) -I >>> sign(1 + I) sign(1 + I) >>> _.evalf() 0.707106781186548 + 0.707106781186548*I Parameters ========== arg : Expr Real or imaginary expression. Returns ======= expr : Expr Complex sign of expression. See Also ======== Abs, conjugate Tc s>t}||kr:|jdjdur:|jdt|jdS|S)NrF)superdoitr!rYAbs)rIrKs __class__r)r*rnFs z sign.doitc CsJ|jr|\}}g}t|}|D]\}|jr4| }q"|jrddlm}dt|jd|dd||jdS|jdjrddlm}dt|jd|dd|tj |jdSdS)Nr) DiracDeltaTrM)r!r/'sympy.functions.special.delta_functionsrr r0rr1)rIrPrr)r)r*rQs     zsign._eval_derivativecCs|jdjrdSdSr[)r!Zis_nonnegativerWr)r)r*_eval_is_nonnegatives zsign._eval_is_nonnegativecCs|jdjrdSdSr[)r!Zis_nonpositiverWr)r)r*_eval_is_nonpositives zsign._eval_is_nonpositivecCs |jdjSrR)r!r0rWr)r)r*_eval_is_imaginaryszsign._eval_is_imaginarycCs |jdjSrRrkrWr)r)r*_eval_is_integerszsign._eval_is_integercCs |jdjSrR)r!rYrWr)r)r*rZszsign._eval_is_zerocCs&t|jdjr"|jr"|jr"tjSdSrR)rr!rY is_integeris_evenrrx)rIotherr)r)r* _eval_powerszsign._eval_powerrcCsV|jd}||d}|dkr(||S|dkr<|||}t|dkrPtj StjSrR)r!subsfuncdirr rrx)rIrPnlogxcdirZarg0Zx0r)r)r* _eval_nseriess    zsign._eval_nseriescKs&|jr"td|dkfd|dkfdSdS)Nrir)rT)r/rrSr)r)r*_eval_rewrite_as_Piecewiseszsign._eval_rewrite_as_PiecewisecKs&ddlm}|jr"||ddSdS)Nr Heavisiderrirrr/rIr@rTrr)r)r*_eval_rewrite_as_Heavisides zsign._eval_rewrite_as_HeavisidecKs tdt|df|t|dfSr[)rrrorSr)r)r*_eval_rewrite_as_Absszsign._eval_rewrite_as_AbscKs|t|jdSrR)rr r!)rIrTr)r)r*_eval_simplifyszsign._eval_simplify)r)r`rarbrcZ is_complexrgrnrhrFr~rrQrrrrrZrrrrrr __classcell__r)r)rqr*rl s(6  1  rlc@seZdZUdZeeed<dZdZdZ dZ dZ d,ddZ e dd Zd d Zd d ZddZddZddZddZddZddZddZddZd-dd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+S).roab Return the absolute value of the argument. Explanation =========== This is an extension of the built-in function ``abs()`` to accept symbolic values. If you pass a SymPy expression to the built-in ``abs()``, it will pass it automatically to ``Abs()``. Examples ======== >>> from sympy import Abs, Symbol, S, I >>> Abs(-1) 1 >>> x = Symbol('x', real=True) >>> Abs(-x) Abs(x) >>> Abs(x**2) x**2 >>> abs(-x) # The Python built-in Abs(x) >>> Abs(3*x + 2*I) sqrt(9*x**2 + 4) >>> Abs(8*I) 8 Note that the Python built-in will return either an Expr or int depending on the argument:: >>> type(abs(-1)) <... 'int'> >>> type(abs(S.NegativeOne)) Abs will always return a SymPy object. Parameters ========== arg : Expr Real or complex expression. Returns ======= expr : Expr Absolute value returned can be an expression or integer depending on input arg. See Also ======== sign, conjugate r!TFricCs$|dkrt|jdSt||dS)zE Get the first derivative of the argument to Abs(). rirN)rlr!r)rIZargindexr)r)r*fdiffsz Abs.fdiffcsddlm}tdr*}|dur*|SttsDtdt|dd\}}|j rx|j sx||||Sj r2g}g}j D]v}|j r|j jr|j jr||j} t| |r||n|t| |j q||} t| |r||q|| qt|}|r$|t|ddntj}||StjurDtjStjurVtjSj r\} } | jr| jr| jrS| tjurtjSt| | S| jr| t| S| j r| t| t tj! t"| SdS| #t$st%| &\} }| t'|}t t| |Stt r.c3s|]}|jdVqdS)rN)r;r!r'ir@r)r*r+cr,cSsi|]}|tddqS)T)real)rrr)r)r* gr,zAbs.eval..cSsg|]}|jdur|qSr$)r/rr)r)r* hr,zAbs.eval..c3s|]}t|VqdSr$)r;r7)r'u)conjr)r*r+ir,)8Zsympy.simplify.simplifyrhasattrr~r6r TypeErrortypeZas_numer_denom free_symbolsrsr!rzrrZ is_negativebaser:rrrrxr-r.InfinityZ as_base_expr/rryrois_extended_nonnegativer ruPir=r;rrr4rr is_positiveis_AddNegativeInfinityanyrYr2Zis_extended_nonpositiver0r1r7atomsallZxreplacerr)r?r@robjrdZknownr|tZbnewZtnewrexponentrCrDzr}Znew_conjr#Z abs_free_argr))r@rr*rF s                   "      zAbs.evalcCs|jdjrdSdSr[r\rWr)r)r* _eval_is_realls zAbs._eval_is_realcCs|jdjr|jdjSdSrR)r!r/rrWr)r)r*rps zAbs._eval_is_integercCst|jdjSrR)r_argsrYrWr)r)r*_eval_is_extended_nonzerotszAbs._eval_is_extended_nonzerocCs |jdjSrR)rrYrWr)r)r*rZwszAbs._eval_is_zerocCs|j}|dur| SdSr$)rY)rIZis_zr)r)r*_eval_is_extended_positivezszAbs._eval_is_extended_positivecCs|jdjr|jdjSdSrR)r!r/Z is_rationalrWr)r)r*_eval_is_rationals zAbs._eval_is_rationalcCs|jdjr|jdjSdSrR)r!r/rrWr)r)r* _eval_is_evens zAbs._eval_is_evencCs|jdjr|jdjSdSrR)r!r/Zis_oddrWr)r)r* _eval_is_odds zAbs._eval_is_oddcCs |jdjSrRrVrWr)r)r*rXszAbs._eval_is_algebraiccCsP|jdjrL|jrL|jr&|jd|S|tjurL|jrL|jd|d|SdSNrri)r!r/rrrryZ is_Integer)rIrr)r)r*rs zAbs._eval_powerrcCsX|jd|d}|t|r2|t||}|jdj|||d}t||S)Nr)rr)r!Zleadtermr;rrrrlexpand)rIrPrrr directionrpr)r)r*rs zAbs._eval_nseriescCs|jdjs|jdjr>t|jd|ddtt|jdSt|jdtt|jd|ddt|jdtt|jd|ddt|jd}| tSrL) r!r/r0r rlr7r r=roZrewrite)rIrPrvr)r)r*rQs zAbs._eval_derivativecKs,ddlm}|jr(||||| SdS)Nrrrrr)r)r*rs zAbs._eval_rewrite_as_HeavisidecKsL|jrt||dkf| dfS|jrHtt|t|dkft |dfSdSr[)r/rr0rrSr)r)r*rszAbs._eval_rewrite_as_PiecewisecKs |t|Sr$rlrSr)r)r*_eval_rewrite_as_signszAbs._eval_rewrite_as_signcKs|t|tjSr$)r7rr{rSr)r)r*_eval_rewrite_as_conjugateszAbs._eval_rewrite_as_conjugateN)ri)r)r`rarbrcrdr rer/rurrfrgrrhrFrrrrZrrrrrXrrrQrrrrr)r)r)r*ros4 9   ^  roc@s<eZdZdZdZdZdZdZeddZ ddZ ddZ d S) r@a Returns the argument (in radians) of a complex number. The argument is evaluated in consistent convention with ``atan2`` where the branch-cut is taken along the negative real axis and ``arg(z)`` is in the interval $(-\pi,\pi]$. For a positive number, the argument is always 0; the argument of a negative number is $\pi$; and the argument of 0 is undefined and returns ``nan``. So the ``arg`` function will never nest greater than 3 levels since at the 4th application, the result must be nan; for a real number, nan is returned on the 3rd application. Examples ======== >>> from sympy import arg, I, sqrt, Dummy >>> from sympy.abc import x >>> arg(2.0) 0 >>> arg(I) pi/2 >>> arg(sqrt(2) + I*sqrt(2)) pi/4 >>> arg(sqrt(3)/2 + I/2) pi/6 >>> arg(4 + 3*I) atan(3/4) >>> arg(0.8 + 0.6*I) 0.643501108793284 >>> arg(arg(arg(arg(x)))) nan >>> real = Dummy(real=True) >>> arg(arg(arg(real))) nan Parameters ========== arg : Expr Real or complex expression. Returns ======= value : Expr Returns arc tangent of arg measured in radians. Tc Cs|}tdD]6}t||r&|jd}q |dkr>|jr>tjSqJq tjSt|tr^t|tS|j st | \}}|j rt dd|jD}t||}n|}tdd|tDrdS|\}}t||}|jr|S||kr||dd SdS) NrrcSs$g|]}t|dvr|nt|qS))rrirrr)r)r*rszarg.eval..css|]}|jduVqdSr$)rvrr)r)r*r+r,zarg.eval..FrM)ranger6r!r/rr-rperiodic_argumentris_Atomr Z as_coeff_Mulrsrrlrrrr4r is_number) r?r@rCrrEZarg_rPyrr)r)r*rFs4        zarg.evalcCsF|jd\}}|t||dd|t||dd|d|dS)NrTrMr)r!r4r )rIrrPrr)r)r*rQs  zarg._eval_derivativecKs|jd\}}t||SrR)r!r4r)rIr@rTrPrr)r)r*_eval_rewrite_as_atan2szarg._eval_rewrite_as_atan2N) r`rarbrcr/is_realr]rgrhrFrQrr)r)r)r*r@s/ r@c@sXeZdZdZdZeddZddZddZd d Z d d Z d dZ ddZ ddZ dS)r7a> Returns the *complex conjugate* [1]_ of an argument. In mathematics, the complex conjugate of a complex number is given by changing the sign of the imaginary part. Thus, the conjugate of the complex number :math:`a + ib` (where $a$ and $b$ are real numbers) is :math:`a - ib` Examples ======== >>> from sympy import conjugate, I >>> conjugate(2) 2 >>> conjugate(I) -I >>> conjugate(3 + 2*I) 3 - 2*I >>> conjugate(5 - I) 5 + I Parameters ========== arg : Expr Real or complex expression. Returns ======= arg : Expr Complex conjugate of arg as real, imaginary or mixed expression. See Also ======== sign, Abs References ========== .. [1] https://en.wikipedia.org/wiki/Complex_conjugation TcCs|}|dur|SdSr$)rr?r@rr)r)r*rFFszconjugate.evalcCstSr$)r7rWr)r)r*inverseLszconjugate.inversecCst|jdddSrLror!rWr)r)r*r~Oszconjugate._eval_AbscCst|jdSrR transposer!rWr)r)r* _eval_adjointRszconjugate._eval_adjointcCs |jdSrRr!rWr)r)r*rUszconjugate._eval_conjugatecCsB|jrtt|jd|ddS|jr>tt|jd|dd SdSrL)rr7r r!r0rOr)r)r*rQXszconjugate._eval_derivativecCst|jdSrRadjointr!rWr)r)r*_eval_transpose^szconjugate._eval_transposecCs |jdjSrRrVrWr)r)r*rXaszconjugate._eval_is_algebraicN)r`rarbrcrgrhrFrr~rrrQrrXr)r)r)r*r7s+ r7c@s4eZdZdZeddZddZddZdd Zd S) ra Linear map transposition. Examples ======== >>> from sympy import transpose, Matrix, MatrixSymbol >>> A = MatrixSymbol('A', 25, 9) >>> transpose(A) A.T >>> B = MatrixSymbol('B', 9, 22) >>> transpose(B) B.T >>> transpose(A*B) B.T*A.T >>> M = Matrix([[4, 5], [2, 1], [90, 12]]) >>> M Matrix([ [ 4, 5], [ 2, 1], [90, 12]]) >>> transpose(M) Matrix([ [4, 2, 90], [5, 1, 12]]) Parameters ========== arg : Matrix Matrix or matrix expression to take the transpose of. Returns ======= value : Matrix Transpose of arg. cCs|}|dur|SdSr$)rrr)r)r*rFsztranspose.evalcCst|jdSrRr7r!rWr)r)r*rsztranspose._eval_adjointcCst|jdSrRrrWr)r)r*rsztranspose._eval_conjugatecCs |jdSrRrrWr)r)r*rsztranspose._eval_transposeN) r`rarbrcrhrFrrrr)r)r)r*res ( rc@sFeZdZdZeddZddZddZdd Zdd d Z d dZ d S)ra Conjugate transpose or Hermite conjugation. Examples ======== >>> from sympy import adjoint, MatrixSymbol >>> A = MatrixSymbol('A', 10, 5) >>> adjoint(A) Adjoint(A) Parameters ========== arg : Matrix Matrix or matrix expression to take the adjoint of. Returns ======= value : Matrix Represents the conjugate transpose or Hermite conjugation of arg. cCs0|}|dur|S|}|dur,t|SdSr$)rrr7rr)r)r*rFs z adjoint.evalcCs |jdSrRrrWr)r)r*rszadjoint._eval_adjointcCst|jdSrRrrWr)r)r*rszadjoint._eval_conjugatecCst|jdSrRrrWr)r)r*rszadjoint._eval_transposeNcGs,||jd}d|}|r(d||f}|S)Nrz %s^{\dagger}z\left(%s\right)^{%s})_printr!)rIprinterrr!r@Ztexr)r)r*_latexs  zadjoint._latexcGsHddlm}|j|jdg|R}|jr8||d}n ||d}|S)Nr) prettyFormu†+)Z sympy.printing.pretty.stringpictrrr!Z _use_unicode)rIrr!rZpformr)r)r*_prettys   zadjoint._pretty)N) r`rarbrcrhrFrrrrrr)r)r)r*rs  rc@s4eZdZdZdZdZeddZddZdd Z d S) polar_lifta Lift argument to the Riemann surface of the logarithm, using the standard branch. Examples ======== >>> from sympy import Symbol, polar_lift, I >>> p = Symbol('p', polar=True) >>> x = Symbol('x') >>> polar_lift(4) 4*exp_polar(0) >>> polar_lift(-4) 4*exp_polar(I*pi) >>> polar_lift(-I) exp_polar(-I*pi/2) >>> polar_lift(I + 2) polar_lift(2 + I) >>> polar_lift(4*x) 4*polar_lift(x) >>> polar_lift(4*p) 4*p Parameters ========== arg : Expr Real or complex expression. See Also ======== sympy.functions.elementary.exponential.exp_polar periodic_argument TFcCsddlm}|jrH||}|dtdt dtfvrHtt|t|S|jrV|j}n|g}g}g}g}|D]2}|j r||g7}ql|j r||g7}ql||g7}qlt |t |kr|rt ||t t |S|rt ||St |tdSdS)Nrrr)Z$sympy.functions.elementary.complexesr@rrrrabsrsr!is_polarrr<rr)r?r@Zargumentarr!rArBZpositiver)r)r*rF s.     zpolar_lift.evalcCs|jd|S)z. Careful! any evalf of polar numbers is flaky r)r! _eval_evalf)rIprecr)r)r*r+szpolar_lift._eval_evalfcCst|jdddSrLrrWr)r)r*r~/szpolar_lift._eval_AbsN) r`rarbrcrrwrhrFrr~r)r)r)r*rs% !rc@s0eZdZdZeddZeddZddZdS) ra Represent the argument on a quotient of the Riemann surface of the logarithm. That is, given a period $P$, always return a value in $(-P/2, P/2]$, by using $\exp(PI) = 1$. Examples ======== >>> from sympy import exp_polar, periodic_argument >>> from sympy import I, pi >>> periodic_argument(exp_polar(10*I*pi), 2*pi) 0 >>> periodic_argument(exp_polar(5*I*pi), 4*pi) pi >>> from sympy import exp_polar, periodic_argument >>> from sympy import I, pi >>> periodic_argument(exp_polar(5*I*pi), 2*pi) pi >>> periodic_argument(exp_polar(5*I*pi), 3*pi) -pi >>> periodic_argument(exp_polar(5*I*pi), pi) 0 Parameters ========== ar : Expr A polar number. period : Expr The period $P$. See Also ======== sympy.functions.elementary.exponential.exp_polar polar_lift : Lift argument to the Riemann surface of the logarithm principal_branch cCs|jr|j}n|g}d}|D]}|js4|t|7}qt|trR||jd7}q|jr|j\}}||t |j |t t |j 7}qt|t r|t|jd7}qdSq|Sr)rsr!rr@r6rrr4rzunbranched_argumentrrrr)r?rr!rfrCr r=r)r)r*_getunbranched\s(  z periodic_argument._getunbranchedcCs|js dS|tkr&t|tr&t|jSt|trL|dtkrLt|jd|S|jrdd|jD}t |t |jkrtt ||S| |}|durdS| tt trdS|tkr|S|tkrt||tj|}| ts||SdS)NrrcSsg|]}|js|qSr))rr'rPr)r)r*rr,z*periodic_argument.eval..)rvrr6principal_branchrr!rrrsr<rrr;rrrrr{)r?rperiodZnewargsrfrr)r)r*rFrs*   zperiodic_argument.evalcCsb|j\}}|tkr2t|}|dur(|S||St|t|}|t||tj||Sr$)r!rrrrrrr{)rIrrrrfubr)r)r*rs   zperiodic_argument._eval_evalfN)r`rarbrcrhrrFrr)r)r)r*r3s (  rcCs t|tS)a\ Returns periodic argument of arg with period as infinity. Examples ======== >>> from sympy import exp_polar, unbranched_argument >>> from sympy import I, pi >>> unbranched_argument(exp_polar(15*I*pi)) 15*pi >>> unbranched_argument(exp_polar(7*I*pi)) 7*pi See also ======== periodic_argument )rrrr)r)r*rsrc@s,eZdZdZdZdZeddZddZdS) ra Represent a polar number reduced to its principal branch on a quotient of the Riemann surface of the logarithm. Explanation =========== This is a function of two arguments. The first argument is a polar number `z`, and the second one a positive real number or infinity, `p`. The result is ``z mod exp_polar(I*p)``. Examples ======== >>> from sympy import exp_polar, principal_branch, oo, I, pi >>> from sympy.abc import z >>> principal_branch(z, oo) z >>> principal_branch(exp_polar(2*pi*I)*3, 2*pi) 3*exp_polar(0) >>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi) 3*principal_branch(z, 2*pi) Parameters ========== x : Expr A polar number. period : Expr Positive real number or infinity. See Also ======== sympy.functions.elementary.exponential.exp_polar polar_lift : Lift argument to the Riemann surface of the logarithm periodic_argument TFc Cst|trt|jd|S|tkr&|St|t}t||}||kr|ts|tst|}dd}|t|}t|t}|ts||krtt |||}n|}|j s|ts|td9}|S|j s|d}} n|j |j \}} g} | D] } | j r|| 9}q| | g7} qt| } t||} | tr6dS| jrt|| ksj| dkr| dkr|dkr| dkrt|tt| |Sttt | t| |t|S| jrt| |dkdks| |dkr| dkrt| t t|SdS)NrcSst|tst|S|Sr$)r6rr)exprr)r)r*mrs z!principal_branch.eval..mrr)rirT)r6rrr!rrr;replacerrrrrtrtuplerrrr) rIrPrrZbargplrresrEmZothersrr@r)r)r*rFs\             ",zprincipal_branch.evalcCsN|j\}}t|||}t|tks0|t kr4|St|tt||Sr$)r!rrrrrr)rIrrrpr)r)r*rs  zprincipal_branch._eval_evalfN) r`rarbrcrrwrhrFrr)r)r)r*rs ( 2rFc shddlm}|jr|S|jr(s(t|St|trBsBrBt|S|jrL|S|jr||j fdd|j D}rxt|S|S|j r|j t jkr| t jt|jddS|jr|j fdd|j DSt||rHt|jd}g}|j ddD]>}t|ddd }t|ddd } ||f| q||ft|S|j fd d|j DSdS) Nr)Integralcsg|]}t|ddqS)Tpause _polarifyr'r@liftr)r*r!r,z_polarify..Frcsg|]}t|ddqS)Frrrrr)r*r(r,rirrcs(g|] }t|tr t|dn|qS)r)r6r rrrr)r*r3s )Zsympy.integrals.integralsrrrrr6rrrrr!rzrrZExp1rrr5functionr:r) eqrrrrrZlimitslimitvarrestr)rr*rs:   rTcCsN|rd}tt||}|s|Sdd|jD}||}|dd|DfS)a Turn all numbers in eq into their polar equivalents (under the standard choice of argument). Note that no attempt is made to guess a formal convention of adding polar numbers, expressions like $1 + x$ will generally not be altered. Note also that this function does not promote ``exp(x)`` to ``exp_polar(x)``. If ``subs`` is ``True``, all symbols which are not already polar will be substituted for polar dummies; in this case the function behaves much like :func:`~.posify`. If ``lift`` is ``True``, both addition statements and non-polar symbols are changed to their ``polar_lift()``ed versions. Note that ``lift=True`` implies ``subs=False``. Examples ======== >>> from sympy import polarify, sin, I >>> from sympy.abc import x, y >>> expr = (-x)**y >>> expr.expand() (-x)**y >>> polarify(expr) ((_x*exp_polar(I*pi))**_y, {_x: x, _y: y}) >>> polarify(expr)[0].expand() _x**_y*exp_polar(_y*I*pi) >>> polarify(x, lift=True) polar_lift(x) >>> polarify(x*(1+y), lift=True) polar_lift(x)*polar_lift(y + 1) Adds are treated carefully: >>> polarify(1 + sin((1 + I)*x)) (sin(_x*polar_lift(1 + I)) + 1, {_x: x}) FcSsi|]}|t|jddqS)T)Zpolar)rname)r'rpr)r)r*rdr,zpolarify..cSsi|]\}}||qSr)r))r'rprr)r)r*rfr,)rrrritems)rrrZrepsr)r)r*polarify7s( rcsFt|tr|jr|S|st|tr2tt|jSt|tr^|jddtkr^t|jdS|j s|j s|j s|j r|j dvrd|jvs|j dvr|jfdd|jDSt|trt|jdS|jrt|j}t|j|jo| }||S|jr,t|jddr,|jfd d|jDS|jfd d|jDS) Nrirr)z==z!=csg|]}t|qSr) _unpolarifyrexponents_onlyr)r*rxr,z_unpolarify..rfFcsg|]}t|qSr)rrr r)r*rscsg|]}t|dqS)Trrr r)r*rr,)r6r rrrr rr!rrrsZ is_BooleanZ is_RelationalZrel_oprrrzrrr5getattr)rr rZexporr)r r*r isF    r NcCst|tr|St|}|dur,t||Sd}d}|r>> from sympy import unpolarify, polar_lift, sin, I >>> unpolarify(polar_lift(I + 2)) 2 + I >>> unpolarify(sin(polar_lift(I + 7))) sin(7 + I) NTFrri)r6boolr unpolarifyrr rr)rrr changedrrr)r)r*rs$   r)F)TF)F)NF)=typingrrdZ sympy.corerrrrrrr Zsympy.core.exprr Zsympy.core.exprtoolsr Zsympy.core.functionr r rrrZsympy.core.logicrrZsympy.core.numbersrrrZsympy.core.powerrZsympy.core.relationalrZ&sympy.functions.elementary.exponentialrrrZ#sympy.functions.elementary.integersrZ(sympy.functions.elementary.miscellaneousrZ$sympy.functions.elementary.piecewiserZ(sympy.functions.elementary.trigonometricrrr r=rlror@r7rrrrrrrrr rr)r)r)r*s> $       z{6z^M9BSfg ! 2