\c@ sddlmZmZddlmZmZmZmZmZm Z m Z ddl m Z ddl mZddlmZmZmZmZddlmZmZddlmZmZmZddlmZdd lmZmZm Z dd l!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(m)Z)defdYZ*defdYZ+defdYZ,defdYZ-defdYZ.defdYZ/defdYZ0defdYZ1defdYZ2d efd!YZ3d"Z4d#efd$YZ5e6d%Z7e8e6d&Z9e6d'Z:ie6d(Z;dd)lm<Z=e-e=_>[=d*S(+i(tprint_functiontdivision(tStAddtMultsympifytSymboltDummytBasic(tExpr(t factor_terms(tFunctiont DerivativetArgumentIndexErrort AppliedUndef(t fuzzy_nottfuzzy_or(tpitItoo(tEq(texpt exp_polartlog(tceiling(tsqrt(t Piecewise(tatantatan2trecB sbeZdZeZeZedZedZdZ dZ dZ dZ dZ RS(s) Returns real 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, I, E >>> from sympy.abc import x, y >>> re(2*E) 2*E >>> re(2*I + 17) 17 >>> re(2*I) 0 >>> re(im(x) + x*I + 2) 2 See Also ======== im c C s|tjkrtjS|tjkr,tjS|jr9|S|jsRtj|jrYtjS|jrp|jdS|j rt |t rt |j dSggg}}}tj|}x|D]}|jtj}|dk r|jsh|j|qhq|jtj r/|jr/|j|q|jd|}|r[|j|dq|j|qWt|t|krd|||gD\} } } || t| | SdS(Nitignorecs s|]}t|VqdS(N(R(t.0txs((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys Ys(RtNaNtComplexInfinitytis_realt is_imaginaryt ImaginaryUnittZerot is_Matrixt as_real_imagt is_Functiont isinstancet conjugateRtargsRt make_argstas_coefficienttNonetappendthastlentim( tclstargtincludedtrevertedtexcludedR,ttermtcoefft real_imagtatbtc((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyteval4s8     "cK s |tjfS(sE Returns the real number with a zero imaginary part. (RR&(tselftdeepthints((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR(]scC s~|js|jdjr9tt|jd|dtS|jsR|jdjrztj tt|jd|dtSdS(Nitevaluate( R#R,RR tTrueR$RR%R3(R@tx((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_derivativecs  cK s#|jdtjt|jdS(Ni(R,RR%R3(R@R5tkwargs((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_rewrite_as_imjscC s|jdjS(Ni(R,t is_algebraic(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_algebraicmscC s$t|jdj|jdjgS(Ni(RR,R$tis_zero(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt _eval_is_zeropscC s)ddlj}|j|jdjS(Nii(tsage.alltallt real_partR,t_sage_(R@tsage((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRPts(t__name__t __module__t__doc__RDR#t unbranchedt classmethodR?R(RFRHRJRLRP(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs)     R3cB sbeZdZeZeZedZedZdZ dZ dZ dZ dZ RS(s/ 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 >>> re(2*I + 17) 17 >>> im(x*I) re(x) >>> im(re(x) + y) im(y) See Also ======== re c C s|tjkrtjS|tjkr,tjS|jr<tjS|jsUtj|jratj |S|jrx|jdS|j rt |t rt |j d Sggg}}}tj|}x|D]}|jtj}|dk r|js |j|qq|j|q|jtjs5|j r|jd|}|ra|j|dqq|j|qqWt|t|krd|||gD\} } } || t| | SdS(NiiRcs s|]}t|VqdS(N(R(RR ((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys s(RR!R"R#R&R$R%R'R(R)R*R+R3R,RR-R.R/R0R1R2R( R4R5R6R7R8R,R9R:R;R<R=R>((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?s8      "cK s |tjfS(s Return the imaginary part with a zero real part. Examples ======== >>> from sympy.functions import im >>> from sympy import I >>> im(2 + 3*I).as_real_imag() (3, 0) (RR&(R@RARB((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR(s cC s~|js|jdjr9tt|jd|dtS|jsR|jdjrztj tt|jd|dtSdS(NiRC( R#R,R3R RDR$RR%R(R@RE((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRFs  cC s)ddlj}|j|jdjS(Nii(RMRNt imag_partR,RP(R@RQ((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRPscK s$tj |jdt|jdS(Ni(RR%R,R(R@R5RG((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_rewrite_as_rescC s|jdjS(Ni(R,RI(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRJscC s|jdjS(Ni(R,R#(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRLs(RRRSRTRDR#RURVR?R(RFRPRXRJRL(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR3ys(     tsigncB seZdZeZeZdZedZdZ dZ dZ dZ dZ dZd Zd Zd Zd Zd ZdZdZRS(sH Returns the complex sign of an expression: 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.functions import sign >>> from sympy.core.numbers import I >>> sign(-1) -1 >>> sign(0) 0 >>> sign(-3*I) -I >>> sign(1 + I) sign(1 + I) >>> _.evalf() 0.707106781186548 + 0.707106781186548*I See Also ======== Abs, conjugate cK s6|jdjtkr2|jdt|jdS|S(Ni(R,RKtFalsetAbs(R@RB((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pytdoitsc C s|jr|j\}}g}t|}x{|D]s}|jrM| }q4|jrYq4t|}|jr|jr|tj 9}|jr| }qq4|j |q4W|tj krt |t |krdS|||j|S|tjkrtjS|jrtjS|jr#tj S|jr3tjS|jrRt|trR|Sn|jr|jr}|jtjkr}tj Stj |}|jrtj S|jrtj SndS(N(tis_Mult as_coeff_mulRYt is_negativet is_positiveR3R$t is_comparableRR%R0tOneR2R/t _new_rawargsR!RKR&t NegativeOneR)R*tis_PowRtHalf( R4R5R>R,tunktsR<taitarg2((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?sJ          '       cC s!t|jdjrtjSdS(Ni(RR,RKRRb(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt _eval_AbsFscC stt|jdS(Ni(RYR+R,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_conjugateJscC s|jdjrOddlm}dt|jd|dt||jdS|jdjrddlm}dt|jd|dt|tj |jdSdS(Nii(t DiracDeltaiRC( R,R#t'sympy.functions.special.delta_functionsRmR RDR$RR%(R@RERm((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRFMs /cC s|jdjrtSdS(Ni(R,tis_nonnegativeRD(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_nonnegativeWscC s|jdjrtSdS(Ni(R,tis_nonpositiveRD(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_nonpositive[scC s|jdjS(Ni(R,R$(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_imaginary_scC s|jdjS(Ni(R,R#(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_integerbscC s|jdjS(Ni(R,RK(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRLescC s3t|jdjr/|jr/|jr/tjSdS(Ni(RR,RKt is_integertis_evenRRb(R@tother((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt _eval_powerhs  cC s)ddlj}|j|jdjS(Nii(RMRNtsgnR,RP(R@RQ((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRPpscK s;|jr7td|dkfd|dkfdtfSdS(Niii(R#RRD(R@R5RG((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_rewrite_as_Piecewisets cK s/ddlm}|jr+||ddSdS(Ni(t Heavisideii(RnR{R#(R@R5RGR{((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_rewrite_as_Heavisidexs cC s|j|jdjS(Ni(tfuncR,tfactor(R@tratiotmeasuretrationaltinverse((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_simplify}s(RRRSRTRDt is_finitet is_complexR\RVR?RkRlRFRpRrRsRtRLRxRPRzR|R(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRYs$' /           R[cB seZdZeZeZeZddZe dZ dZ dZ dZ dZdZd Zd Zd Zd Zd ZdZdZdZdZdZRS(s Return the absolute value of the argument. 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 >>> 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) 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. See Also ======== sign, conjugate icC s0|dkrt|jdSt||dS(s Get the first derivative of the argument to Abs(). Examples ======== >>> from sympy.abc import x >>> from sympy.functions import Abs >>> Abs(-x).fdiff() sign(x) iiN(RYR,R (R@targindex((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pytfdiffs c sEddlm}ddlm}tdrNj}|dk rN|Snttsvt dt n|dt j r+g}g}xPj D]E}||}t||r|j|j dq|j|qWt|}|r|t|dt ntj}||StjkrAtjStjkrWtjSjrnj\} } | jr"| jr| jrS| tjkrtjSt| |r| tjkrSt| | S| jr| t| S| jr| t| ttj t!| SdS| j"t#snt$| j%\} } | t&| } tt| | Snttrttj dStt'rdSj(rj"tjtj)rt*dj%DrtjSnj+rtj,Sjr Sj-r Sj.r@tj/ }|jr@|Sn|j0dt j1t0j1t0}|rt2fd |DrdSkrA krAj1t}j3d |D}g|j4D]} | jdkr| ^q}| s*t2fd |D rAt5|SndS( Ni(tsignsimp(t expand_mulRksBad argument type for Abs(): %sRCics s|]}|jVqdS(N(t is_infinite(RR<((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys sc3 s%|]}j|jdVqdS(iN(R1R,(Rti(R5(sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys scS s"i|]}tdt|qS(treal(RRD(RR((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys s c3 s$|]}jt|VqdS(N(R1R+(Rtu(tconj(sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys s(6tsympy.simplify.simplifyRtsympy.core.functionRthasattrRkR/R*R t TypeErrorttypeRZR]R,R0RRRbR!R"tInfinityRet as_base_expR#RuRvRdR[RoRR_RtPiR3R1RRR(RRtis_AddtNegativeInfinitytanyRKR&RqR$R%R+tatomsRNtxreplacet free_symbolsR(R4R5RRtobjtknownRgttttnewtbasetexponentR<R=tzRjtnew_conjRt abs_free_arg((R5RsClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?s     '      '!      "+$cC s"|jdjr|jdjSdS(Ni(R,R#Ru(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRt scC st|jdjS(Ni(Rt_argsRK(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_nonzeroscC s|jdjS(Ni(RRK(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRLscC s|j}|dk r| SdS(N(RKR/(R@tis_z((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_positives  cC s"|jdjr|jdjSdS(Ni(R,R#t is_rational(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_is_rationalscC s"|jdjr|jdjSdS(Ni(R,R#Rv(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt _eval_is_even scC s"|jdjr|jdjSdS(Ni(R,R#tis_odd(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt _eval_is_odd$scC s|jdjS(Ni(R,RI(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRJ(scC sg|jdjrc|jrc|jr1|jd|S|tjk rc|jrc|jd|d|SndS(Nii(R,R#RuRvRRdt is_Integer(R@R((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRx+s  cC sz|jdj|d}|jdj|d|d|}t|d}t|j|d|ft||tfS(Nitntlogx(R,tleadtermt _eval_nseriesRRtsubsRYRD(R@RERRt directionRhtwhen((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR3s "cC s)ddlj}|j|jdjS(Nii(RMRNt abs_symbolicR,RP(R@RQ((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRP<scC s|jdjs |jdjrQt|jd|dttt|jdSt|jdtt|jd|dtt|jdtt|jd|dtt |jd}|j tS(NiRC( R,R#R$R RDRYR+RR3R[trewrite(R@REtrv((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRF@s )*"cK s6ddlm}|jr2||||| SdS(Ni(R{(RnR{R#(R@R5RGR{((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR|Is cK s-|jr)t||dkf| tfSdS(Ni(R#RRD(R@R5RG((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRzPs cK s|t|S(N(RY(R@R5RG((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_rewrite_as_signTs(RRRSRTRDR#RZR_RURRVR?RtRRLRRRRRJRxRRPRFR|RzR(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR[s*$ Q            R5cB s;eZdZeZeZedZdZdZ RS(s5 Returns the argument (in radians) of a complex number. For a positive number, the argument is always 0. Examples ======== >>> from sympy.functions import arg >>> from sympy import I, sqrt >>> arg(2.0) 0 >>> arg(I) pi/2 >>> arg(sqrt(2) + I*sqrt(2)) pi/4 cC st|trt|tS|jst|j\}}|jrtg|j D]*}t |dkrq|n t |^qS}nt ||}n|}|j t rdS|j \}}t||}|jr|S||kr||dtSdS(NiiRC(ii(R*Rtperiodic_argumentRtis_AtomR t as_coeff_MulR]RR,RYRRR(Rt is_numberRZ(R4R5R>targ_R<REtyR((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?ns"   =  cC sW|jdj\}}|t||dt|t||dt|d|dS(NiRCi(R,R(R RD(R@RRER((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRFscK s&|jdj\}}t||S(Ni(R,R(R(R@R5RGRER((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_rewrite_as_atan2s( RRRSRTRDR#RRVR?RFR(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR5Xs  R+cB sSeZdZedZdZdZdZdZdZ dZ RS(s- Returns the `complex conjugate` Ref[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 See Also ======== sign, Abs References ========== .. [1] https://en.wikipedia.org/wiki/Complex_conjugation cC s |j}|dk r|SdS(N(RlR/(R4R5R((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?s  cC st|jddtS(NiRC(R[R,RD(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRkscC st|jdS(Ni(t transposeR,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt _eval_adjointscC s |jdS(Ni(R,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRlscC sW|jr)tt|jd|dtS|jrStt|jd|dt SdS(NiRC(R#R+R R,RDR$(R@RE((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRFs   cC st|jdS(Ni(tadjointR,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_eval_transposescC s|jdjS(Ni(R,RI(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRJs( RRRSRTRVR?RkRRlRFRRJ(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR+s     RcB s8eZdZedZdZdZdZRS(s# Linear map transposition. cC s |j}|dk r|SdS(N(RR/(R4R5R((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?s  cC st|jdS(Ni(R+R,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRscC st|jdS(Ni(RR,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRlscC s |jdS(Ni(R,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs(RRRSRTRVR?RRlR(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs   RcB sMeZdZedZdZdZdZddZ dZ RS(s5 Conjugate transpose or Hermite conjugation. cC sB|j}|dk r|S|j}|dk r>t|SdS(N(RR/RR+(R4R5R((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?s     cC s |jdS(Ni(R,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRscC st|jdS(Ni(RR,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRlscC st|jdS(Ni(R+R,(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRscG sF|j|jd}d|}|rBd||j|f}n|S(Nis %s^{\dagger}s\left(%s\right)^{%s}(t_printR,(R@tprinterRR,R5ttex((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_latexs  cG sYddlm}|j|jd|}|jrE||d}n||d}|S(Ni(t prettyFormiu†t+(t sympy.printing.pretty.stringpictRRR,t _use_unicode(R@RR,Rtpform((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_prettys  N( RRRSRTRVR?RRlRR/RR(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs    t polar_liftcB s;eZdZeZeZedZdZ dZ RS(s4 Lift argument to the Riemann surface of the logarithm, using the standard branch. >>> 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 See Also ======== sympy.functions.elementary.exponential.exp_polar periodic_argument cC sLddlm}|jra||}|dtdt dtfkratt|t|Sn|jrv|j}n |g}g}g}g}xM|D]E}|j r||g7}q|j r||g7}q||g7}qWt |t |krH|rt ||t t |S|r1t ||St |tdSndS(Ni(R5ii(t$sympy.functions.elementary.complexesR5RRRRtabsR]R,tis_polarR`R2RR(R4R5targumenttarR,R6R8tpositive((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?'s.  !      cC s|jdj|S(s. Careful! any evalf of polar numbers is flaky i(R,t _eval_evalf(R@tprec((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRIscC st|jddtS(NiRC(R[R,RD(R@((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRkMs( RRRSRTRDRRZRaRVR?RRk(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs " RcB s5eZdZedZedZdZRS(s 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(P*I) == 1. >>> from sympy import exp, exp_polar, periodic_argument, unbranched_argument >>> from sympy import I, pi >>> unbranched_argument(exp(5*I*pi)) pi >>> unbranched_argument(exp_polar(5*I*pi)) 5*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 See Also ======== sympy.functions.elementary.exponential.exp_polar polar_lift : Lift argument to the Riemann surface of the logarithm principal_branch cC s|jr|j}n |g}d}x|D]}|jsM|t|7}q+t|trv||jjd7}q+|jr|jj\}}||t |j |t t |j 7}q+t|t r|t|jd7}q+dSq+W|S(Nii(R]R,RR5R*RRR(Retunbranched_argumentRRRRR/(R4RR,RUR<RR3((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyt_getunbranchedls"       (cC s[|js dS|tkr5t|tr5t|jSt|trh|dtkrht|jd|S|j rg|jD]}|js{|^q{}t |t |jkrtt ||Sn|j |}|dkrdS|j tttrdS|tkr|S|tkrWt||tdd|}|j tsW||SndS(Niii(R`R/RR*tprincipal_branchRR,RRR]R2RRR1RRRR(R4RtperiodREtnewargsRUR((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?s*   %   "cC s|j\}}|tkrGtj|}|dkr:|S|j|St|tj|}|t||tdd|j|S(Nii(R,RRRR/RRR(R@RRRRUtub((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs   (RRRSRTRVRR?R(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRQscC s t|tS(N(RR(R5((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRsRcB s2eZdZeZeZedZdZ RS(s Represent a polar number reduced to its principal branch on a quotient of the Riemann surface of the logarithm. This is a function of two arguments. The first argument is a polar number `z`, and the second one a positive real number of infinity, `p`. The result is "z mod exp_polar(I*p)". >>> 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) See Also ======== sympy.functions.elementary.exponential.exp_polar polar_lift : Lift argument to the Riemann surface of the logarithm periodic_argument c sddlm}m}m}m}mmt|rQt|j d|S||kra|St ||}t ||}||krZ|j t  rZ|j t  rZ|} fd} | j | } t | |}| j sZ||kr ||||| } n| } | j rS| j | rS| |d9} n| Sn|jss|d} } n|j|j\} } g}x1| D])}|jr| |9} q||g7}qWt|} t | |}|j t rdS|jrt| |ks2|dkr| dkr| dkr|dkr[t| t|| |St||||| |t| S|jrt||dktks||dkr| d kr|||t| SdS( Ni(RRRRRRic st|s|S|S(N(R*(texpr(RR(sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pytmrs ii((((tsympyRRRRRRR*RR,RR1treplaceRRR^R`ttupleR/RRRRD(R@RERRRRRRtbargtplRtresR>tmtothersRR5((RRsClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyR?sP.        $ +5 cC sddlm}m}m}|j\}}t||j|}t||ksb|| krf|St||||j|S(Ni(RRR(RRRRR,RRR(R@RRRRRRtp((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs ( RRRSRTRDRRZRaRVR?R(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs 4c C sddlm}|jr|S|jr7| r7t|St|tr]| r]|r]t|S|jrj|S|jr|j g|j D]}t ||dt ^q}|rt|S|S|j r|j g|j D]}t ||dt^qSt||rt |j|d|}g}xa|j dD]R}t |ddtd|} t |dd|d|} |j| f| q1W||ft|S|j g|j D]0}t|trt ||d|n|^qSdS(Ni(tIntegraltpauseiitlift(RRRRRR*RRRR}R,t _polarifyRDR)RZtfunctionR0RR ( teqRRRR5trR}tlimitstlimittvartrest((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRs4     4  2 cC sj|rt}ntt||}|s.|Sd|jD}|j|}|d|jDfS(s 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 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. >>> 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}) cS s(i|]}t|jdt|qS(tpolar(RtnameRD(RRh((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys Ps cS si|]\}}||qS(((RRhR((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pys Rs (RZRRRRtitems(RRRtreps((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pytpolarify&s% cC st|t s|jr|S|s%t|trHtt|j|St|tr|jddtkrt|jd|S|j s|j s|j s|j r|j dkrd|jks|j dkr|jg|jD]}t||^qSt|tr%t|jd|Sn|jrht|j|}t|j||joY| }||S|jrt|jdtr|jg|jD]}t|||^qS|jg|jD]}t||t^qS( Niiis==s!=RU(s==s!=(s==s!=(R*RRRRt _unpolarifyRR,RRR]t is_Booleant is_Relationaltrel_opR}RReRRuR)tgetattrRZRD(Rtexponents_onlyRREtexpoR((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRUs.& ,   &cC st|tr|St|}|ikr>t|j|St}t}|rYt}nxP|rt}t|||}||krt}|}nt|tr\|Sq\W|jidtd6dt d6S(s If p denotes the projection from the Riemann surface of the logarithm to the complex line, return a simplified version eq' of `eq` such that p(eq') == p(eq). Also apply the substitution subs in the end. (This is a convenience, since ``unpolarify``, in a certain sense, undoes polarify.) >>> from sympy import unpolarify, polar_lift, sin, I >>> unpolarify(polar_lift(I + 2)) 2 + I >>> unpolarify(sin(polar_lift(I + 7))) sin(7 + I) ii( R*tboolRt unpolarifyRRDRZRRR(RRRtchangedRR((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyRus$      (tbasicN(?t __future__RRt sympy.coreRRRRRRRtsympy.core.exprR tsympy.core.exprtoolsR RR R R Rtsympy.core.logicRRtsympy.core.numbersRRRtsympy.core.relationalRt&sympy.functions.elementary.exponentialRRRt#sympy.functions.elementary.integersRt(sympy.functions.elementary.miscellaneousRt$sympy.functions.elementary.piecewiseRt(sympy.functions.elementary.trigonometricRRRR3RYR[R5R+RRRRRRRZRRDRRRRt_tabs_(((sClib/python2.7/site-packages/sympy/functions/elementary/complexes.pyts>4"cm59,JX Z / '