o 8Vaa@sddlmZmZmZmZmZmZmZddlm Z ddl m Z ddl m Z mZmZmZddlmZmZddlmZmZmZddlmZddlmZmZmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&Gd dde Z'Gddde Z(Gddde Z)Gddde Z*Gddde Z+Gddde Z,Gddde Z-Gddde Z.Gddde Z/Gdd d e Z0d!d"Z1Gd#d$d$e Z2d0d&d'Z3d1d)d*Z4d0d+d,Z5id%fd-d.Z6d/S)2)SAddMulsympifySymbolDummyBasic)Expr) factor_terms)Function DerivativeArgumentIndexError AppliedUndef) fuzzy_notfuzzy_or)piIoo)Eq)exp exp_polarlog)ceiling)sqrt) Piecewise)atanatan2c@beZdZdZdZdZdZeddZdddZ ddZ d d Z d d Z d dZ ddZddZdS)rea 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, 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 Tc CsF|tjurtjS|tjurtjS|jr|S|jstj|jr!tjS|jr*|dS|j r9t |t r9t |j dSggg}}}t|}|D]9}|tj}|dur]|js\||qH|tjsl|jrl||qH|j|d}|r|||dqH||qHt|t|krdd|||fD\} } } || t| | SdS)Nrignorecs|]}t|VqdSNr.0Zxsr&F/usr/lib/python3/dist-packages/sympy/functions/elementary/complexes.py gzre.eval..)rNaNComplexInfinityis_extended_real is_imaginary ImaginaryUnitZero is_Matrix as_real_imag is_Function isinstance conjugaterargsr make_argsas_coefficientappendhaslenim clsargincludedZrevertedexcludedr5ZtermZcoeffZ real_imagabcr&r&r'evalBs<         zre.evalcK |tjfS)zF Returns the real number with a zero imaginary part. rr/selfZdeephintsr&r&r'r1k zre.as_real_imagcC`|js |jdjrtt|jd|ddS|js|jdjr.tj tt|jd|ddSdSNrTZevaluate)r,r5rr r-rr.r;rHxr&r&r'_eval_derivativerzre._eval_derivativecKs|jdtjt|jdSNr)r5rr.r;rHr>kwargsr&r&r'_eval_rewrite_as_imyszre._eval_rewrite_as_imcC |jdjSrRr5Z is_algebraicrHr&r&r'_eval_is_algebraic| zre._eval_is_algebraiccCst|jdj|jdjgSrR)rr5r-is_zerorXr&r&r' _eval_is_zeroszre._eval_is_zerocC|jdjrdSdSNrTr5 is_finiterXr&r&r'_eval_is_finite zre._eval_is_finitecCr]r^r_rXr&r&r'_eval_is_complexrbzre._eval_is_complexNT)__name__ __module__ __qualname____doc__r, unbranched_singularities classmethodrDr1rPrUrYr\rarcr&r&r&r'rs)  ( rc@r)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 Tc CsP|tjurtjS|tjurtjS|jrtjS|jstj|jr%tj |S|jr.|dS|j r>t |t r>t |j d Sggg}}}t|}|D]9}|tj}|durh|jsb||qM||qM|tjsq|js|j|d}|r||dqM||qMt|t|krdd|||fD\} } } || t| | SdS)Nrrcsr!r"r#r$r&r&r'r(r)zim.eval..)rr*r+r,r/r-r.r0r1r2r3r4r;r5rr6r7r8r9r:rr<r&r&r'rDs<          zim.evalcKrE)zC Return the imaginary part with a zero real part. rFrGr&r&r'r1rJzim.as_real_imagcCrKrL)r,r5r;r r-rr.rrNr&r&r'rPrQzim._eval_derivativecKs tj |jdt|jdSrR)rr.r5rrSr&r&r'_eval_rewrite_as_re zim._eval_rewrite_as_recCrVrRrWrXr&r&r'rYrZzim._eval_is_algebraiccCrVrRr5r,rXr&r&r'r\rZzim._eval_is_zerocCr]r^r_rXr&r&r'rarbzim._eval_is_finitecCr]r^r_rXr&r&r'rcrbzim._eval_is_complexNrd)rerfrgrhr,rirjrkrDr1rPrmrYr\rarcr&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.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 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)superdoitr5r[Abs)rHrIs __class__r&r'rr@s z sign.doitc CsD|jrX|\}}g}t|}|D].}|jr| }q|jrq|jr:t|}|jr4|tj 9}|jr3| }q| |q| |q|tj urOt |t |krOdS|||j |S|tjur`tjS|jrftjS|jrltj S|jrrtjS|jr|t|tr||S|jr|jr|jtjurtj Stj |}|jrtj S|jrtj SdSdSr")is_Mul as_coeff_mulrpis_extended_negativeis_extended_positiver-r; is_comparablerr.r8Oner:Z _new_rawargsr*r[r/ NegativeOner2r3is_PowrHalf) r=r>rCr5unkrtrAZaiarg2r&r&r'rDFsT       z sign.evalcCst|jdjr tjSdSrR)rr5r[rr|rXr&r&r' _eval_Absxszsign._eval_AbscCstt|jdSrR)rpr4r5rXr&r&r'_eval_conjugate|zsign._eval_conjugatecCs|jdjrddlm}dt|jd|dd||jdS|jdjrBddlm}dt|jd|dd|tj |jdSdS)Nr) DiracDeltaTrM)r5r,'sympy.functions.special.delta_functionsrr r-rr.)rHrOrr&r&r'rPs     zsign._eval_derivativecCr]r^)r5Zis_nonnegativerXr&r&r'_eval_is_nonnegativerbzsign._eval_is_nonnegativecCr]r^)r5Zis_nonpositiverXr&r&r'_eval_is_nonpositiverbzsign._eval_is_nonpositivecCrVrR)r5r-rXr&r&r'_eval_is_imaginaryrZzsign._eval_is_imaginarycCrVrRrorXr&r&r'_eval_is_integerrZzsign._eval_is_integercCrVrR)r5r[rXr&r&r'r\rZzsign._eval_is_zerocCs.t|jdjr|jr|jrtjSdSdSdSrR)rr5r[ is_integeris_evenrr|)rHotherr&r&r' _eval_powers zsign._eval_powerrcCsV|jd}||d}|dkr||S|dkr|||}t|dkr(tj StjSrR)r5subsfuncdirrrr|)rHrOnlogxcdirZarg0Zx0r&r&r' _eval_nseriess    zsign._eval_nseriescKs&|jrtd|dkfd|dkfdSdS)Nrlr)rT)r,rrSr&r&r'_eval_rewrite_as_Piecewiseszsign._eval_rewrite_as_PiecewisecKs&ddlm}|jr||ddSdS)Nr Heavisiderrlrrr,rHr>rTrr&r&r'_eval_rewrite_as_Heavisides zsign._eval_rewrite_as_HeavisidecKs tdt|df|t|dfSr^)rrrsrSr&r&r'_eval_rewrite_as_Absrnzsign._eval_rewrite_as_AbscKs|t|jdSrR)rr r5)rHrTr&r&r'_eval_simplifyszsign._eval_simplifyr)rerfrgrhZ is_complexrjrrrkrDrrrPrrrrr\rrrrrr __classcell__r&r&rur'rps*7  1   rpc@seZdZdZdZdZdZdZdZd+ddZ e ddZ d d Z d d Z d dZddZddZddZddZddZddZddZd,ddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*S)-rsaV 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 TFrlcCs |dkr t|jdSt||)zE Get the first derivative of the argument to Abs(). rlr)rpr5r )rHZargindexr&r&r'fdiffs z Abs.fdiffcsddlm}ddlm}ddlm}tdr!}|dur!|Stt s.t dt |dd \}}|j rH|j sH||||Sjrg}g} jD];} | jry| jjry| jjry|| j} t| |ro| | qR||| | jqR|| } t| |r| | qR|| qRt|}| r|t| ddntj} || StjurtjStjurtjSjr\} }| jr|jr|jrȈS| tjurtjSt | |S| j!r| t"|S| j#r| t"|ttj$ t%|SdS| &t'st(| )\}}|t*|}tt"||Sttr tt"jdStt+r5j,r,Sjr3 SdSj-rQ&tjtj.rQt/d d )DrQtjSj0rXtj1Sj!r^Sj2re Sj3rutj4 }|j!ru|Sjr{dS|5dd6t56t5}|rt7fd d |DrdSkr׈ krو6t }8d d |D}dd|j D} | rt7fdd | Dst9|SdSdSdS)Nr)signsimp) expand_mul)PowrzBad argument type for Abs(): %sFrMcss|]}|jVqdSr")Z is_infiniter%rAr&r&r'r(KszAbs.eval..c3s |] }|jdVqdS)rN)r9r5r%ir>r&r'r(]scSsi|]}|tddqS)T)real)rrr&r&r' azAbs.eval..cSsg|] }|jdur|qSr")r,rr&r&r' bzAbs.eval..c3s|] }t|VqdSr")r9r4)r%u)conjr&r'r(cs):Zsympy.simplify.simplifyrsympy.core.functionrZsympy.core.powerrhasattrrr3r TypeErrortypeZas_numer_denom free_symbolsrwr5r~rrZ is_negativebaser8rrr|r*r+ZInfinityZ as_base_expr,rr}rsis_extended_nonnegativerryZPir;r9rrr1rr is_positiveis_AddZNegativeInfinityanyr[r/Zis_extended_nonpositiver-r.r4atomsallZxreplacer)r=r>rrrobjrdZknownrtZbnewZtnewrexponentrArBzrZnew_conjr Z abs_free_argr&)r>rr'rDs                     "      zAbs.evalcCr]r^r_rXr&r&r' _eval_is_realfrbzAbs._eval_is_realcC|jdjr |jdjSdSrR)r5r,rrXr&r&r'rj  zAbs._eval_is_integercCst|jdjSrR)r_argsr[rXr&r&r'_eval_is_extended_nonzeronszAbs._eval_is_extended_nonzerocCrVrR)rr[rXr&r&r'r\qrZzAbs._eval_is_zerocCs|j}|dur | SdSr")r[)rHZis_zr&r&r'_eval_is_extended_positivetszAbs._eval_is_extended_positivecCrrR)r5r,Z is_rationalrXr&r&r'_eval_is_rationalyrzAbs._eval_is_rationalcCrrR)r5r,rrXr&r&r' _eval_is_even}rzAbs._eval_is_evencCrrR)r5r,Zis_oddrXr&r&r' _eval_is_oddrzAbs._eval_is_oddcCrVrRrWrXr&r&r'rYrZzAbs._eval_is_algebraiccCsP|jdjr&|jr&|jr|jd|S|tjur&|jr&|jd|d|SdSNrrl)r5r,rrrr}Z is_Integer)rHrr&r&r'rs zAbs._eval_powerrcCsX|jd|d}|t|r|t||}|jdj|||d}t||S)Nr)rr)r5Zleadtermr9rrrrpexpand)rHrOrrrZ directionrtr&r&r'rs zAbs._eval_nseriescCs|jdjs |jdjrt|jd|ddtt|jdSt|jdtt|jd|ddt|jdtt|jd|ddt|jd}| tSrL) r5r,r-r rpr4rr;rsZrewrite)rHrOrvr&r&r'rPs  zAbs._eval_derivativecKs,ddlm}|jr||||| SdS)Nrrrrr&r&r'rs zAbs._eval_rewrite_as_HeavisidecKsL|jrt||dkf| dfS|jr$tt|t|dkft |dfSdSr^)r,rr-rrSr&r&r'rs $zAbs._eval_rewrite_as_PiecewisecKs |t|Sr"rprSr&r&r'_eval_rewrite_as_signrZzAbs._eval_rewrite_as_signcKs|t|tjSr")r4rrrSr&r&r'_eval_rewrite_as_conjugaterzAbs._eval_rewrite_as_conjugateN)rlr)rerfrgrhr,ryrrirjrrkrDrrrr\rrrrrYrrrPrrrrr&r&r&r'rss49  `   rsc@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. 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 >>> arg(sqrt(3)/2 + I/2) pi/6 >>> arg(4 + 3*I) atan(3/4) >>> arg(0.8 + 0.6*I) 0.643501108793284 Parameters ========== arg : Expr Real or complex expression. Returns ======= value : Expr Returns arc tangent of arg measured in radians. TcCst|tr t|tS|js)t|\}}|jr"tdd|j D}t ||}n|}t dd| t Dr9dS|\}}t||}|jrI|S||krS||ddSdS)NcSs$g|]}t|dvr |nt|qS))rrlrrr&r&r'rs zarg.eval..css|]}|jduVqdSr")rzrr&r&r'r(szarg.eval..FrM)r3rperiodic_argumentris_Atomr Z as_coeff_Mulrwrr5rprrrr1r is_number)r=r>rCZarg_rOyrr&r&r'rDs&     zarg.evalcCsF|jd\}}|t||dd|t||dd|d|dS)NrTrMr)r5r1r )rHrrOrr&r&r'rPs  zarg._eval_derivativecKs|jd\}}t||SrR)r5r1r)rHr>rTrOrr&r&r'_eval_rewrite_as_atan2s zarg._eval_rewrite_as_atan2N) rerfrgrhr,is_realr`rjrkrDrPrr&r&r&r'r>s&  r>c@sPeZdZdZdZeddZddZddZd d Z d d Z d dZ ddZ dS)r4a< 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 >>> 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 TcC|}|dur |SdSr")rr=r>rr&r&r'rD-zconjugate.evalcCt|jdddSrLrsr5rXr&r&r'r3rzconjugate._eval_AbscCt|jdSrR transposer5rXr&r&r' _eval_adjoint6zconjugate._eval_adjointcC |jdSrRr5rXr&r&r'r9 zconjugate._eval_conjugatecCsB|jrtt|jd|ddS|jrtt|jd|dd SdSrL)rr4r r5r-rNr&r&r'rP<s zconjugate._eval_derivativecCrrRadjointr5rXr&r&r'_eval_transposeBrzconjugate._eval_transposecCrVrRrWrXr&r&r'rYErZzconjugate._eval_is_algebraicN) rerfrgrhrjrkrDrrrrPrrYr&r&r&r'r4s+  r4c@s4eZdZdZeddZddZddZdd Zd S) ra Linear map transposition. Examples ======== >>> from sympy.functions import transpose >>> from sympy.matrices import MatrixSymbol >>> from sympy import Matrix >>> 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. cCrr")rrr&r&r'rDtrztranspose.evalcCrrRr4r5rXr&r&r'rzrztranspose._eval_adjointcCrrRrrXr&r&r'r}rztranspose._eval_conjugatecCrrRrrXr&r&r'rrztranspose._eval_transposeN) rerfrgrhrkrDrrrr&r&r&r'rIs*  rc@sFeZdZdZeddZddZddZdd Zdd d Z d dZ d S)ra Conjugate transpose or Hermite conjugation. Examples ======== >>> from sympy import adjoint >>> from sympy.matrices import 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|}|durt|SdSr")rrr4rr&r&r'rDsz adjoint.evalcCrrRrrXr&r&r'rrzadjoint._eval_adjointcCrrRrrXr&r&r'rrzadjoint._eval_conjugatecCrrRrrXr&r&r'rrzadjoint._eval_transposeNcGs,||jd}d|}|rd||f}|S)Nrz %s^{\dagger}z\left(%s\right)^{%s})_printr5)rHprinterrr5r>Ztexr&r&r'_latexs  zadjoint._latexcGsJddlm}|j|jdg|R}|jr||d}|S||d}|S)Nr) prettyFormu†+)Z sympy.printing.pretty.stringpictrrr5Z _use_unicode)rHrr5rZpformr&r&r'_prettys   zadjoint._prettyr") rerfrgrhrkrDrrrrrr&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}|jr$||}|dtdt dtfvr$tt|t|S|jr+|j}n|g}g}g}g}|D]}|j rA||g7}q6|j rJ||g7}q6||g7}q6t |t |krv|rft ||t t |S|rnt ||St |tdSdS)Nrrr)Z$sympy.functions.elementary.complexesr>rrrrabsrwr5is_polarrr:rr)r=r>argumentarr5r?r@Zpositiver&r&r'rDs0     zpolar_lift.evalcCs|jd|S)z. Careful! any evalf of polar numbers is flaky r)r5 _eval_evalf)rHprecr&r&r'rszpolar_lift._eval_evalfcCrrLrrXr&r&r'rrzpolar_lift._eval_AbsN) rerfrgrhrr{rkrDrrr&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(P*I) == 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 : ExprT 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]I}|js|t|7}qt|tr)||jd7}q|jrF|j\}}||t |j |t t |j 7}qt|t rU|t|jd7}qdS|Sr)rwr5rr>r3rrr1r~unbranched_argumentrrrr)r=rr5rirArr;r&r&r'_getunbranchedCs(  z periodic_argument._getunbranchedcCs|jsdS|tkrt|trt|jSt|tr&|dtkr&t|jd|S|jrAdd|jD}t |t |jkrAtt ||S| |}|durLdS| tt trUdS|tkr[|S|tkrst||tj|}| tsu||SdSdS)NrrcSsg|]}|js|qSr&)rr%rOr&r&r'rfz*periodic_argument.eval..)rzrr3principal_branchrr5rrrwr:rrr9rrrrr)r=rperiodZnewargsrirr&r&r'rDYs.   zperiodic_argument.evalcCsb|j\}}|tkrt|}|dur|S||St|t|}|t||tj||Sr")r5rrrrrrr)rHrrrriubr&r&r'rus    zperiodic_argument._eval_evalfN)rerfrgrhrkrrDrr&r&r&r'rs(   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'rs rc@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 TFcsddlm}m}m}m}mmt|rt|j d|S||kr#|St ||}t ||}||krw| t sw| t sw|} fdd} | | } t | |}| sw||kre||||| } n| } | j su| |su| |d9} | S|js|d} } n|j|j\} } g}| D]}|jr| |9} q||g7}qt|} t | |}| t rdS|jrt| |ks|dkr| dkr| dkr|dkrt| t|| |St||||| |t| S|jrt||dkdks||dkr | dkr|||t| SdSdSdS) Nr)rrrrrrcst|s |S|Sr")r3)exprrrr&r'mrs z!principal_branch.eval..mrr&rlrT)sympyrrrrrrr3rr5rr9replacerrrxrtuplerrr)rHrOrrrrrrZbargplrresrCmZothersrr>r&rr'rDs`             "* zprincipal_branch.evalcCsbddlm}m}m}|j\}}t|||}t||ks"|| kr$|St|||||S)Nr)rrr)rrrrr5rrr)rHrrrrrrpr&r&r'rs  zprincipal_branch._eval_evalfN) rerfrgrhrr{rkrDrr&r&r&r'rs(  3rFc s`ddlm}|jr |S|jrst|St|tr!s!r!t|S|jr&|S|jr>|j fdd|j D}rliftr&r'r rz_polarify..Frcr)Frr r r r&r'rrrlrr cs(g|]}t|trt|dn|qS)r)r3r r r rr&r'rs  )rrrrrr3rrrrr5r~rrZExp1r rr2functionr8r) eqrr rrrZlimitslimitvarrestr&rr'r s:   r TcCsN|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 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%rtr&r&r'rMszpolarify..cSsi|]\}}||qSr&r&)r%rtrr&r&r'rOr)r rrritems)rrrZrepsr&r&r'polarify s( rcsBt|tr|jr |S|sdt|trtt|jSt|tr/|jddtkr/t|jdS|j sJ|j sJ|j sJ|j rW|j dvrEd|jvsJ|j dvrW|jfdd|jDSt|trdt|jdS|jr}t|j}t|j|jov| }||S|jrt|jddr|jfd d|jDS|jfd d|jDS) Nrlrr)z==z!=csg|]}t|qSr& _unpolarifyrexponents_onlyr&r'rarz_unpolarify..riFcsg|]}t|qSr&rrrr&r'rlscsg|]}t|dqSrdrrrr&r'ror)r3rrrrrrr5rrrwZ is_BooleanZ is_RelationalZrel_oprrr~rrr2getattr)rrr Zexporr&rr'rRsF    rcCst|tr|St|}|ikrt||Sd}d}|rd}|r9d}t|||}||kr0d}|}t|tr7|S|s |tddtddiS)a 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.) Examples ======== >>> from sympy import unpolarify, polar_lift, sin, I >>> unpolarify(polar_lift(I + 2)) 2 + I >>> unpolarify(sin(polar_lift(I + 7))) sin(7 + I) TFrrl)r3boolr unpolarifyrrrr)rrrZchangedr rr&r&r'rrs&    rN)F)TF)7Z sympy.corerrrrrrrZsympy.core.exprr Zsympy.core.exprtoolsr rr r r rZsympy.core.logicrrZsympy.core.numbersrrrZsympy.core.relationalrZ&sympy.functions.elementary.exponentialrrrZ#sympy.functions.elementary.integersrZ(sympy.functions.elementary.miscellaneousrZ$sympy.functions.elementary.piecewiserZ(sympy.functions.elementary.trigonometricrrrr;rprsr>r4rrrrrrr rrrr&r&r&r's<$      xy7zKJ;CSf i ! 2