U ;qLe@sddlmZddlmZmZmZmZmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZddlmZmZddlmZmZmZddlmZdd lmZdd l m!Z!dd l"m#Z#Gd d d eZ$GdddeZ%GdddeZ&GdddeZ'GdddeZ(GdddeZ)GdddeZ*GdddeZ+GdddeZ,GdddeZ-d d!Z.Gd"d#d#eZ/d/d%d&Z0d0d(d)Z1d1d*d+Z2d2d-d.Z3d,S)3)Tuple)SAddMulsympifySymbolDummyBasic)Expr) factor_terms)Function DerivativeArgumentIndexError AppliedUndef expand_mul) fuzzy_notfuzzy_or)piIoo)Pow)Eq)sqrt) Piecewisec@speZdZUdZeeed<dZdZdZ e ddZ dddZ dd Z d d Zd d ZddZddZddZdS)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 argsTc CsD|tjkrtjS|tjkr tjS|jr*|S|js:t|jr@tjS|jrR|dS|j rpt |t rpt |j dSggg}}}t|}|D]p}|t}|dk r|js||q|ts|jr||q|j|d}|r||dq||qt|t|kr@dd|||fD\} } } || t| | SdS)Nrignorecss|]}t|VqdSNr.0xsr#{/home/p21-0144/sympy/latex2sympy2solve-back-end/sympyEq/lib/python3.8/site-packages/sympy/functions/elementary/complexes.py iszre.eval..)rNaNComplexInfinityis_extended_real is_imaginaryrZero is_Matrix as_real_imag is_Function isinstance conjugaterrr make_argsas_coefficientappendhaslenim clsargincludedZrevertedexcludedrtermcoeff real_imagabcr#r#r$evalDs8         zre.evalcKs |tjfS)zF Returns the real number with a zero imaginary part. rr*selfdeephintsr#r#r$r,mszre.as_real_imagcCs^|js|jdjr*tt|jd|ddS|js<|jdjrZt tt|jd|ddSdSNrTevaluate)r(rrr r)rr5rDxr#r#r$_eval_derivativets zre._eval_derivativecKs|jdtt|jdSNr)rrr5rDr8kwargsr#r#r$_eval_rewrite_as_im{szre._eval_rewrite_as_imcCs |jdjSrMr is_algebraicrDr#r#r$_eval_is_algebraic~szre._eval_is_algebraiccCst|jdj|jdjgSrM)rrr)is_zerorSr#r#r$ _eval_is_zeroszre._eval_is_zerocCs|jdjrdSdSNrTr is_finiterSr#r#r$_eval_is_finites zre._eval_is_finitecCs|jdjrdSdSrWrXrSr#r#r$_eval_is_complexs zre._eval_is_complexN)T)__name__ __module__ __qualname____doc__tTupler __annotations__r( unbranched_singularities classmethodrAr,rLrPrTrVrZr[r#r#r#r$rs )  ( rc@speZdZUdZeeed<dZdZdZ e ddZ dddZ dd Z d d Zd d ZddZddZddZdS)r5a 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 rTc CsL|tjkrtjS|tjkr tjS|jr,tjS|js.)rr&r'r(r*r)rr+r,r-r.r/r5rrr0r1r2r3r4rr6r#r#r$rAs8          zim.evalcKs |tjfS)zC Return the imaginary part with a zero real part. rBrCr#r#r$r,szim.as_real_imagcCs^|js|jdjr*tt|jd|ddS|js<|jdjrZt tt|jd|ddSdSrG)r(rr5r r)rrrJr#r#r$rLs zim._eval_derivativecKst |jdt|jdSrM)rrrrNr#r#r$_eval_rewrite_as_reszim._eval_rewrite_as_recCs |jdjSrMrQrSr#r#r$rTszim._eval_is_algebraiccCs |jdjSrMrr(rSr#r#r$rVszim._eval_is_zerocCs|jdjrdSdSrWrXrSr#r#r$rZs zim._eval_is_finitecCs|jdjrdSdSrWrXrSr#r#r$r[s zim._eval_is_complexN)T)r\r]r^r_r`r rar(rbrcrdrAr,rLrfrTrVrZr[r#r#r#r$r5s )  ' r5cseZdZdZdZdZfddZeddZddZ 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:|jdjdkr:|jdt|jdS|S)NrF)superdoitrrUAbs)rDrFs __class__r#r$rjCs z sign.doitc Cs@|jr|\}}g}t|}|D]Z}|jr4| }q"|jraiarg2r#r#r$rAIsN      z sign.evalcCst|jdjrtjSdSrM)rrrUrrtrSr#r#r$ _eval_Abs{szsign._eval_AbscCstt|jdSrM)rhr/rrSr#r#r$_eval_conjugateszsign._eval_conjugatecCs|jdjr>ddlm}dt|jd|dd||jdS|jdjrddlm}dt|jd|dd|t |jdSdS)Nr) DiracDeltaTrH)rr('sympy.functions.special.delta_functionsrr r)r)rDrKrr#r#r$rLs     zsign._eval_derivativecCs|jdjrdSdSrW)ris_nonnegativerSr#r#r$_eval_is_nonnegatives zsign._eval_is_nonnegativecCs|jdjrdSdSrW)ris_nonpositiverSr#r#r$_eval_is_nonpositives zsign._eval_is_nonpositivecCs |jdjSrM)rr)rSr#r#r$_eval_is_imaginaryszsign._eval_is_imaginarycCs |jdjSrMrgrSr#r#r$_eval_is_integerszsign._eval_is_integercCs |jdjSrM)rrUrSr#r#r$rVszsign._eval_is_zerocCs&t|jdjr"|jr"|jr"tjSdSrM)rrrU is_integeris_evenrrt)rDotherr#r#r$ _eval_powerszsign._eval_powerrcCsV|jd}||d}|dkr(||S|dkr<|||}t|dkrPtj StjSrM)rsubsfuncdirrrrt)rDrKnlogxcdirarg0x0r#r#r$ _eval_nseriess    zsign._eval_nseriescKs&|jr"td|dkfd|dkfdSdS)Nrer)rT)r(rrNr#r#r$_eval_rewrite_as_Piecewiseszsign._eval_rewrite_as_PiecewisecKs&ddlm}|jr"||ddSdS)Nr Heavisiderrerrr(rDr8rOrr#r#r$_eval_rewrite_as_Heavisides zsign._eval_rewrite_as_HeavisidecKs tdt|df|t|dfSrW)rrrkrNr#r#r$_eval_rewrite_as_Absszsign._eval_rewrite_as_AbscKs|t|jdSrM)rr r)rDrOr#r#r$_eval_simplifyszsign._eval_simplify)r)r\r]r^r_ is_complexrcrjrdrAr}r~rLrrrrrVrrrrrr __classcell__r#r#rmr$rh s(6  1  rhc@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).rkab 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 rTFrecCs$|dkrt|jdSt||dS)zE Get the first derivative of the argument to Abs(). rerN)rhrr)rDargindexr#r#r$fdiffsz Abs.fdiffcsddlm}tdr*}|dk r*|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}||StjkrDtjStjkrTtSddlm } m} j r*\} }| jr|jr|jrS| tjkrtjSt| |S| j r| t!|S| j"r| t!|| t# t$|SdS| %t&s*| | '\}}|t(|}| t!||St| rH| t!j dStt)rrj*r`Sjrn SdSj+r%ttj,rt-dd 'DrtSj.rtj/Sj rSj0rΈ Sj1rt( }|j r|SjrdS|2dd3t23t2}|r>t4fd d |Dr>dSkr kr3t}5d d |D}d d|j D}|rt4fdd |Dst6t7SdS)Nr)signsimpr}zBad argument type for Abs(): %sFrH)rxlogcss|] }|jVqdSr) is_infiniter!r>r#r#r$r%PszAbs.eval..c3s|]}|jdVqdS)rN)r3rr!ir8r#r$r%bscSsi|]}|tddqS)T)real)rrr#r#r$ fszAbs.eval..cSsg|]}|jdkr|qSr)r(rr#r#r$ gs zAbs.eval..c3s|]}t|VqdSr)r3r/)r!u)conjr#r$r%hs)8sympy.simplify.simplifyrhasattrr}r.r TypeErrortypeas_numer_denom free_symbolsrorrwrxr is_negativebaser2rrrrtr&r'r&sympy.functions.elementary.exponentialr as_base_expr(rrvrkis_extended_nonnegativerrqrr5r3rr,rr is_positiveis_AddNegativeInfinityanyrUr*is_extended_nonpositiver)r/atomsallxreplacerr)r7r8robjrdknownrztZbnewtnewrxrrexponentr>r?zr|Znew_conjrZ abs_free_argr#)r8rr$rA s                          zAbs.evalcCs|jdjrdSdSrWrXrSr#r#r$ _eval_is_realks zAbs._eval_is_realcCs|jdjr|jdjSdSrM)rr(rrSr#r#r$ros zAbs._eval_is_integercCst|jdjSrMr_argsrUrSr#r#r$_eval_is_extended_nonzerosszAbs._eval_is_extended_nonzerocCs |jdjSrM)rrUrSr#r#r$rVvszAbs._eval_is_zerocCst|jdjSrMrrSr#r#r$_eval_is_extended_positiveyszAbs._eval_is_extended_positivecCs|jdjr|jdjSdSrM)rr( is_rationalrSr#r#r$_eval_is_rational|s zAbs._eval_is_rationalcCs|jdjr|jdjSdSrM)rr(rrSr#r#r$ _eval_is_evens zAbs._eval_is_evencCs|jdjr|jdjSdSrM)rr(is_oddrSr#r#r$ _eval_is_odds zAbs._eval_is_oddcCs |jdjSrMrQrSr#r#r$rTszAbs._eval_is_algebraiccCsP|jdjrL|jrL|jr&|jd|S|tjk rL|jrL|jd|d|SdS)Nrre)rr(rrrrv is_Integer)rDrr#r#r$rs zAbs._eval_powerrcCsdddlm}|jd|d}|||r>||||}|jdj|||d}t||S)Nr)r)rr) rrrleadtermr3rrrhexpand)rDrKrrrr directionrlr#r#r$rs  zAbs._eval_nseriescCs|jdjs|jdjr>t|jd|ddtt|jdSt|jdtt|jd|ddt|jdtt|jd|ddt|jd}| tSrG) rr(r)r rhr/rr5rkrewrite)rDrKrvr#r#r$rLs zAbs._eval_derivativecKs,ddlm}|jr(||||| SdS)Nrrrrr#r#r$rs zAbs._eval_rewrite_as_HeavisidecKsL|jrt||dkf| dfS|jrHtt|t|dkft |dfSdSrW)r(rr)rrNr#r#r$rszAbs._eval_rewrite_as_PiecewisecKs |t|SrrhrNr#r#r$_eval_rewrite_as_signszAbs._eval_rewrite_as_signcKst|t|Sr)rr/rNr#r#r$_eval_rewrite_as_conjugateszAbs._eval_rewrite_as_conjugateN)re)r)r\r]r^r_r`r rar(rqrrbrcrrdrArrrrVrrrrrTrrrLrrrrr#r#r#r$rks4 9   `  rkc@s<eZdZdZdZdZdZdZeddZ ddZ ddZ d S) r8a 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 tjSddlm}t||rjt|t S|j st | \}}|j rtdd|jD}t||}n|}tdd|tDrdSdd lm}|\}} || |} | jr| S||kr ||d d SdS) Nrr exp_polarcSs$g|]}t|dkr|nt|qS))rrerrr#r#r$rszarg.eval..css|]}|jdkVqdSr)rrrr#r#r$r%szarg.eval..atan2FrH)ranger.rr(rr&rrperiodic_argumentris_Atomr as_coeff_Mulrorrhrrr(sympy.functions.elementary.trigonometricrr, is_number) r7r8r>rrr@arg_rrKyrr#r#r$rAs8           zarg.evalcCsF|jd\}}|t||dd|t||dd|d|dS)NrTrHr)rr,r )rDrrKrr#r#r$rLs  zarg._eval_derivativecKs(ddlm}|jd\}}|||S)Nrr)rrrr,)rDr8rOrrKrr#r#r$_eval_rewrite_as_atan2s zarg._eval_rewrite_as_atan2N) r\r]r^r_r(is_realrYrcrdrArLrr#r#r#r$r8s/ r8c@sXeZdZdZdZeddZddZddZd d Z d d Z d dZ ddZ ddZ dS)r/a> 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|}|dk r|SdSr)r~r7r8rr#r#r$rAGszconjugate.evalcCstSr)r/rSr#r#r$inverseMszconjugate.inversecCst|jdddSrGrkrrSr#r#r$r}Pszconjugate._eval_AbscCst|jdSrM transposerrSr#r#r$ _eval_adjointSszconjugate._eval_adjointcCs |jdSrMrrSr#r#r$r~Vszconjugate._eval_conjugatecCsB|jrtt|jd|ddS|jr>tt|jd|dd SdSrG)rr/r rr)rJr#r#r$rLYszconjugate._eval_derivativecCst|jdSrMadjointrrSr#r#r$_eval_transpose_szconjugate._eval_transposecCs |jdjSrMrQrSr#r#r$rTbszconjugate._eval_is_algebraicN)r\r]r^r_rcrdrArr}rr~rLrrTr#r#r#r$r/s+ r/c@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|}|dk r|SdSr)rrr#r#r$rAsztranspose.evalcCst|jdSrMr/rrSr#r#r$rsztranspose._eval_adjointcCst|jdSrMrrSr#r#r$r~sztranspose._eval_conjugatecCs |jdSrMrrSr#r#r$rsztranspose._eval_transposeN) r\r]r^r_rdrArr~rr#r#r#r$rfs ( 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|}|dk r|S|}|dk r,t|SdSr)rrr/rr#r#r$rAs z adjoint.evalcCs |jdSrMrrSr#r#r$rszadjoint._eval_adjointcCst|jdSrMrrSr#r#r$r~szadjoint._eval_conjugatecCst|jdSrMrrSr#r#r$rszadjoint._eval_transposeNcGs,||jd}d|}|r(d||f}|S)Nrz %s^{\dagger}z\left(%s\right)^{%s})_printr)rDprinterrxrr8texr#r#r$_latexs  zadjoint._latexcGsFddlm}|j|jdf|}|jr6||d}n ||d}|S)Nr) prettyFormu†+) sympy.printing.pretty.stringpictrrr _use_unicode)rDrrrpformr#r#r$_prettys   zadjoint._pretty)N) r\r]r^r_rdrArr~rrrr#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 TFc Cs ddlm}|jrT||}|dtdt dtfkrTddlm}|t|t|S|jrb|j }n|g}g}g}g}|D]2}|j r||g7}qx|j r||g7}qx||g7}qxt |t |kr|rt ||tt |S|rt ||Sddlm}t ||dSdS)Nrrrr)$sympy.functions.elementary.complexesr8rrrrrabsroris_polarrr4rr) r7r8argumentarrrr9r:positiver#r#r$rA s2       zpolar_lift.evalcCs|jd|S)z. Careful! any evalf of polar numbers is flaky r)r _eval_evalf)rDprecr#r#r$r.szpolar_lift._eval_evalfcCst|jdddSrGrrSr#r#r$r}2szpolar_lift._eval_AbsN) r\r]r^r_rrsrdrArr}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 c Csddlm}m}|jr|j}n|g}d}|D]}|jsD|t|7}q,t||rb||j d7}q,|j r|j \}}||t |j ||t |j 7}q,t|tr|t|jd7}q,dSq,|S)Nr)rrre)rrrrorrr8r.rxr,rwunbranched_argumentrrr) r7rrrrrbr>rr5r#r#r$_getunbranched_s*  z periodic_argument._getunbranchedc Cs |js dS|tkr&t|tr&t|jSt|trL|dtkrLt|jd|S|jrdd|jD}t |t |jkrtt ||S| |}|dkrdSddl m }m}|t||rdS|tkr|S|tkrddlm}|||tj|}||s||SdS)NrrcSsg|]}|js|qSr#)rr!rKr#r#r$rsz*periodic_argument.eval..)atanrceiling)rrrr.principal_branchrrrrror4rr rr rr3#sympy.functions.elementary.integersr rry) r7rperiodnewargsrbr rr rr#r#r$rAvs.     zperiodic_argument.evalcCsn|j\}}|tkr2t|}|dkr(|S||St|t|}ddlm}||||tj||S)Nrr ) rrrr rrr rry)rDrrrrbubr r#r#r$rs    zperiodic_argument._eval_evalfN)r\r]r^r_rdr rArr#r#r#r$r6s (  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 TFcCsddlm}t|tr&t|jd|S|tkr2|St|t}t||}||kr|ts|tst|}dd}| t|}t|t}|ts||kr|t |||}n|}|j s||s||d9}|S|j s|d} } n|j |j \} } g} | D]"} | jr| | 9} n | | g7} qt| } t| |} | trDdS| jrt| | ksx| dkr| dkr| dkr| dkrt| tt| |St|t | t| |t| S| jrt| |dkdks| |dkr| dkr|| t t| SdS) NrrcSst|tst|S|Sr)r.rr)exprr#r#r$mrs z!principal_branch.eval..mrr#rerT)rrr.rrrrrr3replacerrrrprtuplerrrr)rDrKrrrbargplrresr@mothersrr8r#r#r$rAs^             ",zprincipal_branch.evalcCsZ|j\}}t|||}t|tks0|t kr4|Sddlm}t||t||S)Nr)rx)rrrrrrrxr)rDrrrprxr#r#r$rs   zprincipal_branch._eval_evalfN) r\r]r^r_rrsrdrArr#r#r#r$rs ( 3rFc 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!r8liftr#r$r*sz_polarify..Frcsg|]}t|ddqS)Frr r"r#r#r$r1srer$rcs(g|] }t|tr t|dn|qS)r)r.r r!r"r%r#r$r<s)sympy.integrals.integralsrrrrr.rrrrrrwrrExp1r!rxr-functionr2r) eqr$rrrrlimitslimitvarrestr#r%r$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 :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)polar)rname)r!rlr#r#r$rmszpolarify..cSsi|]\}}||qSr#r#)r!rlr*r#r#r$ros)r!rrritems)r)rr$repsr#r#r$polarify@s( r3csXt|tr|jr|S|sddlm}m}t||rB|t|jSt|trn|jddt krnt|jdS|j s|j s|j s|j r|jdkrd|jks|jdkr|jfdd|jDSt|trt|jdS|jr t|j}t|j|jo| }||S|jr>t|jdd r>|jfd d|jDS|jfd d|jDS) Nr)rxrrer)z==z!=csg|]}t|qSr# _unpolarifyr exponents_onlyr#r$rsz_unpolarify..rbFcsg|]}t|qSr#r4r r6r#r$rscsg|]}t|dqS)Tr4r r6r#r$rs)r.r rrrxrr5rrrrro is_Boolean is_Relationalrel_oprrrwrrr-getattr)r)r7rrxrexporr#r6r$r5rsH    r5NcCst|tr|St|}|dk r,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) NTFrrre) r.boolr unpolarifyrr5rrr)r)rr7changedrrrr#r#r$r>s&    r>)F)TF)F)NF)4typingrr` sympy.corerrrrrrr sympy.core.exprr Zsympy.core.exprtoolsr sympy.core.functionr r rrrsympy.core.logicrrsympy.core.numbersrrrsympy.core.powerrsympy.core.relationalr(sympy.functions.elementary.miscellaneousr$sympy.functions.elementary.piecewiserrr5rhrkr8r/rrrrrrr!r3r5r>r#r#r#r$s8 $      z{6{aM9BUji ! 2 !