XhddlmZddlmZmZmZmZmZmZm Z ddl m Z ddl m Z ddlmZmZmZmZmZmZddlmZmZddlmZmZmZddlmZdd lmZdd l m!Z!dd l"m#Z#Gd d eZ$GddeZ%GddeZ&GddeZ'GddeZ(GddeZ)GddeZ*GddeZ+GddeZ,GddeZ-d Z.Gd!d"eZ/d*d$Z0d+d&Z1d*d'Z2d,d)Z3d(S)-) annotations)SAddMulsympifySymbolDummyBasic)Expr) factor_terms)DefinedFunction DerivativeArgumentIndexError AppliedUndef expand_mul PoleError) fuzzy_notfuzzy_or)piIoo)Pow)Eq)sqrt) PiecewisecleZdZUdZded<dZdZdZedZ ddZ dZ dZ d Z d Zd Zd Zd S)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 tuple[Expr]argsTc|tjur tjS|tjur tjS|jr|S|jst |zjr tjS|jr|dS|j r/t|trt|j dSggg}}}tj|}|D]}|t }||js||;|t s|jr||r||}|r||d||t'|t'|kr1d|||fD\} } } || t)| z | zSdS)Nrignorec3(K|] }t|VdSNr.0xss v/var/www/tools.fuzzalab.pt/emblema-extractor/venv/lib/python3.11/site-packages/sympy/functions/elementary/complexes.py zre.eval..i&MM38MMMMMM)rNaNComplexInfinityis_extended_real is_imaginaryrZero is_Matrix as_real_imag is_Function isinstance conjugaterrr make_argsas_coefficientappendhaslenim clsargincludedrevertedexcludedrtermcoeff real_imagabcs r)evalzre.evalDs !%<<5L A% % %5L  !! *J   *!C%!9 *6M ] *##%%a( ( _ *C!;!; *chqk?? ",.r2hH=%%D . .++A..$ 1/ ...! .)> .OOD)))) !% 1 1 1 = =I .  ! 5555 ----4yyCMM))MMx8.LMMM1as1vv1~))*)r,c |tjfS)zF Returns the real number with a zero imaginary part. rr1selfdeephintss r)r3zre.as_real_imagm af~r,c$|js|jdjr*tt|jd|dS|js|jdjr3t t t|jd|dzSdSNrTevaluate)r/rrrr0rr<rMxs r)_eval_derivativezre._eval_derivativet  B1!> Bj1q4@@@AA A > ATYq\6 A2Z ! a$???@@A A A Ar,c b|jdtt|jdzz SNr)rrr<rMr?kwargss r)_eval_rewrite_as_imzre._eval_rewrite_as_im{s&y|a49Q< 0 0000r,c&|jdjSrZr is_algebraicrMs r)_eval_is_algebraiczre._eval_is_algebraic~y|((r,cdt|jdj|jdjgSrZ)rrr0is_zeroras r) _eval_is_zerozre._eval_is_zeros'12DIaL4HIJJJr,c.|jdjrdSdSNrTr is_finiteras r)_eval_is_finitezre._eval_is_finite" 9Q< ! 4  r,c.|jdjrdSdSrhriras r)_eval_is_complexzre._eval_is_complexrlr,NT)__name__ __module__ __qualname____doc____annotations__r/ unbranched_singularities classmethodrIr3rWr]rbrfrkrnr,r)rrs''RJN&*&*[&*PAAA111)))KKKr,rcleZdZUdZded<dZdZdZedZ ddZ dZ dZ d Z d Zd Zd Zd S)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 rrTc|tjur tjS|tjur tjS|jr tjS|jst |zjr t |zS|jr|dS|j r0t|trt|j d Sggg}}}tj|}|D]}|t }|3|js||;||Q|t s|jsI||}|r||d||t'|t'|kr1d|||fD\} } } || t)| z| zSdS)Nrr!c3(K|] }t|VdSr$r%r&s r)r*zim.eval..r+r,)rr-r.r/r1r0rr2r3r4r5r6r<rrr7r8r9r:r;rr=s r)rIzim.evals !%<<5L A% % %5L  ! *6M   *!C%!9 *28O ] *##%%a( ( _ *C!;!; *sx{OO# #+-r2hH=%%D . .++A..$ 1/ .... ....XXa[[.(=.!% 1 1 1 = =I .  ! 5555 ---4yyCMM))MMx8.LMMM1as1vv1~))*)r,c |tjfS)zC Return the imaginary part with a zero real part. rKrLs r)r3zim.as_real_imagrPr,c$|js|jdjr*tt|jd|dS|js|jdjr3t t t|jd|dzSdSrR)r/rr<rr0rrrUs r)rWzim._eval_derivativerXr,c dt |jdt|jdz zSrZ)rrrr[s r)_eval_rewrite_as_rezim._eval_rewrite_as_res(r49Q<"TYq\"2"2233r,c&|jdjSrZr_ras r)rbzim._eval_is_algebraicrcr,c&|jdjSrZrr/ras r)rfzim._eval_is_zeroy|,,r,c.|jdjrdSdSrhriras r)rkzim._eval_is_finiterlr,c.|jdjrdSdSrhriras r)rnzim._eval_is_complexrlr,Nro)rprqrrrsrtr/rurvrwrIr3rWrrbrfrkrnrxr,r)r<r<s''RJN%*%*[%*NAAA444)))---r,r<ceZdZdZdZdZfdZedZdZ dZ dZ dZ d Z d Zd Zd Zd ZddZdZdZdZdZxZS)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 t}||kr<|jdjdur(|jdt |jdz S|S)NrF)superdoitrreAbs)rMrOs __class__s r)rz sign.doitCsT GGLLNN 991-669Q<#dil"3"33 3r,c`|jr|\}}g}t|}|D]r}|jr| } |jr|jrAt |}|jr|tz}|jr| }G| |]| |s|tj ur"t|t|krdS|||j |zS|tjur tjS|jr tjS|jr tj S|jr tjS|jrt'|tr|S|jrI|jr|jtjurtSt |z}|jrtS|jr t SdSdSr$)is_Mul as_coeff_mulris_extended_negativeis_extended_positiver0r< is_comparablerr9rOner; _new_rawargsr-rer1 NegativeOner4r5is_PowexpHalf) r>r?rHrunkrrFaiarg2s r)rIz sign.evalIs : 3&&((GAtCQA & &)&AA+&~ &UU+*FA!6'&'BJJqMMMM 1 AEzzc#hh#d))33tss+3+S1222 2 !%<<5L ; 6M  # 5L  # != ? #t$$    z cg//28D( ( r     r,c\t|jdjr tjSdSrZ)rrrerrras r) _eval_Abszsign._eval_Abs{s, TYq\) * * 5L  r,cPtt|jdSrZ)rr6rras r)_eval_conjugatezsign._eval_conjugatesIdil++,,,r,cT|jdjr=ddlm}dt |jd|dz||jdzS|jdjrFddlm}dt |jd|dz|t |jdzzSdS)Nr) DiracDeltaTrS)rr/'sympy.functions.special.delta_functionsrrr0r)rMrVrs r)rWzsign._eval_derivatives 9Q< ( 0 J J J J J Jz$)A,DAAAA*TYq\**+ + Yq\ & 0 J J J J J Jz$)A,DAAAA*aR$)A,.//0 0 0 0r,c.|jdjrdSdSrh)ris_nonnegativeras r)_eval_is_nonnegativezsign._eval_is_nonnegative" 9Q< & 4  r,c.|jdjrdSdSrh)ris_nonpositiveras r)_eval_is_nonpositivezsign._eval_is_nonpositiverr,c&|jdjSrZ)rr0ras r)_eval_is_imaginaryzsign._eval_is_imaginaryrcr,c&|jdjSrZrras r)_eval_is_integerzsign._eval_is_integerrr,c&|jdjSrZ)rreras r)rfzsign._eval_is_zerosy|##r,ct|jdjr|jr|jrt jSdSdSdSrZ)rrre is_integeris_evenrr)rMothers r) _eval_powerzsign._eval_powersY dil* + +     M  5L       r,rc|jd}||d}|dkr||S|dkr|||}t |dkr t j n t jSrZ)rsubsfuncdirrrr)rMrVnlogxcdirarg0x0s r) _eval_nserieszsign._eval_nseriessqy| YYq!__ 7799R== 19988At$$DDAvv150r,c N|jrtd|dkfd|dkfdSdS)Nr{r)rT)r/rr[s r)_eval_rewrite_as_Piecewisezsign._eval_rewrite_as_Piecewises<   Eaq\Ba=)DD D E Er,c Bddlm}|jr||dzdz SdS)Nr Heavisiderr{rrr/rMr?r\rs r)_eval_rewrite_as_Heavisidezsign._eval_rewrite_as_HeavisidesAEEEEEE   *9S>>A%) ) * *r,c ftdt|df|t|z dfSrh)rrrr[s r)_eval_rewrite_as_Abszsign._eval_rewrite_as_Abss-!RQZZ3S>4*@AAAr,c \|t|jdSrZ)rr r)rMr\s r)_eval_simplifyzsign._eval_simplifys"yydil33444r,r)rprqrrrs is_complexrvrrwrIrrrWrrrrrfrrrrrr __classcell__)rs@r)rr sH44lJN //[/b---000)))---$$$1111EEE*** BBB5555555r,rceZdZUdZded<dZdZdZdZdZ ddZ e dZ d Z d Zd Zd Zd ZdZdZdZdZdZddZdZdZdZdZdZdS)rab 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 rrTFr{cb|dkrt|jdSt||)zE Get the first derivative of the argument to Abs(). r{r)rrr)rMargindexs r)fdiffz Abs.fdiffs1 q== ! %% %$T844 4r,c6 ddlm}tdr}||St t st dtz|d\}}|j r|j s||||z Sj rg}g}j D]}|j rw|j jrk|j jr_||j} t | |r||W|t%| |j ||} t | |r|||| t'|}|r|t'|dn t(j}||zSt(jur t(jSt(jurt0Sddlm } m} j r\} }| jr|jr5|jrS| t(jur t(jSt?| |zS| j r| tC|zS| j"r5| tC|z| tF tI|zzSdS| %tLsH| | '\}}|tP|zz}| tC||zSt | r#| tCj dSt tRrj*rSjr SdSj+rW%t0t(j,r2t[d'Drt0Sj.r t(j/Sj rSj0r Sj1rtP z}|j r|SjrdS|2d3td3tdz }|rtifd |DrdSkr kr3t>}5d |D}d |j D}|rtifd |Ds#tmtozSdSdSdS) Nr)signsimprzBad argument type for Abs(): %sFrS)rlogc3$K|] }|jV dSr$) is_infiniter'rFs r)r*zAbs.eval..Ps$==Q1=======r,c3XK|]$}|jdV%dS)rN)r:r)r'ir?s r)r*zAbs.eval..bs5AA1CGGAF1I..AAAAAAr,c0i|]}|tdS)T)real)r r'rs r) zAbs.eval..fs%(M(M(MEt,<,<,<(M(M(Mr,c g|] }|j | Sr$)r/rs r) zAbs.eval..gs VVV1;M;U1;U;U;Ur,c3\K|]&}t|V'dSr$)r:r6)r'uconjs r)r*zAbs.eval..hs5!F!FQ$((9Q<<"8"8!F!F!F!F!F!Fr,)8sympy.simplify.simplifyrhasattrrr5r TypeErrortypeas_numer_denom free_symbolsrrrrr is_negativebaser9rrrrr-r.r&sympy.functions.elementary.exponentialr as_base_expr/rrris_extended_nonnegativerrrr<r:rr3rr is_positiveis_AddNegativeInfinityanyrer1is_extended_nonpositiver0r6atomsallxreplacerr)r>r?robjrdknownrtbnewtnewrrrexponentrFrGzrnew_conjr" abs_free_argrs ` @r)rIzAbs.eval sw444444 3 $ $ --//C #t$$ K=S IJJ JhsU+++!!##1 > !!. !3q66##a&&= : ECX + +8 + 0 +QU5F +3qv;;D!$,,7 1  Squ%5%566663q66D!$,,+ 1  T****KE47B##c3i%0000QUC9  !%<<5L !# # #ICCCCCCCC : + __..ND($ +&/'#" q},, u t99h../.H--,G!EBxLL0bSH5E1F1FFFXXf%% +s4yy--//1!Gs2hqj>>*** c3   (3r#(1+'' ' c< ( (    t F : #''"a&899 ==#*:*:*<*<=====  ; 6M  & J  & 4K   28D+     Fx %888::i((399Y+?+??  AAAAAAAAA  F $;;34%<<YYs^^F<<(M(Mf(M(M(MNNLVVl7VVVC 2c!F!F!F!F#!F!F!FFF 2Js4x00111 ;<< 2 2r,c.|jdjrdSdSrhriras r) _eval_is_realzAbs._eval_is_realkrlr,cN|jdjr|jdjSdSrZ)rr/rras r)rzAbs._eval_is_integeros, 9Q< ( +9Q<* * + +r,c@t|jdjSrZr_argsreras r)_eval_is_extended_nonzerozAbs._eval_is_extended_nonzerosA.///r,c&|jdjSrZ)rreras r)rfzAbs._eval_is_zerovsz!}$$r,c@t|jdjSrZrras r)_eval_is_extended_positivezAbs._eval_is_extended_positiveyr r,cN|jdjr|jdjSdSrZ)rr/ is_rationalras r)_eval_is_rationalzAbs._eval_is_rational|s, 9Q< ( ,9Q<+ + , ,r,cN|jdjr|jdjSdSrZ)rr/rras r) _eval_is_evenzAbs._eval_is_evens, 9Q< ( (9Q<' ' ( (r,cN|jdjr|jdjSdSrZ)rr/is_oddras r) _eval_is_oddzAbs._eval_is_odds, 9Q< ( '9Q<& & ' 'r,c&|jdjSrZr_ras r)rbzAbs._eval_is_algebraicrcr,c|jdjrI|jrB|jr|jd|zS|tjur|jr|jd|dz z|zSdS)Nrr{)rr/rrrr is_Integer)rMrs r)rzAbs._eval_powersm 9Q< ( 9X-@ 9 9y|X--..83F.y|hl3D88r,rcbddlm}|jd|d}|||r||||}|jd|||}t||zS)Nr)r)rr) rrrleadtermr:rrrexpand)rMrVrrrr directionrs r)rzAbs._eval_nseriess>>>>>>IaL))!,,Q/ ==Q  5!ss1vvt44I IaL & &qAD & 9 9Y!))+++r,cT|jdjs|jdjrEt|jd|dt t |jdzSt |jdtt |jd|dzt|jdtt|jd|dzzt|jdz }| tSrR) rr/r0rrr6rr<rrewrite)rMrVrvs r)rWzAbs._eval_derivatives 9Q< ( 0DIaL,E 0dilA===y1..//0 01Bty|,<,>> 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|}tdD]<}t||r|jd} |dkr|jrtjcSn tjSddlm}m}t||rt|tSt||rWt|jd}|j r6|dtj zz}|tj kr|dtj zz}|S|jsVt|\}}|jrt%d|jD}t'||z}n|}t)d|t,DrdSddlm} |\} } | | | } | jr| S||kr ||d SdS) Nrrr exp_polarcRg|]$}t|dvr|nt|%S))rr{r#rs r)rzarg.eval..sC000 !$(77'#9#9QQGG000r,c3(K|] }|jduVdSr$)rrs r)r*zarg.eval.. s*PP!q%-PPPPPPr,atan2FrS)ranger5rr/rr-rrr+periodic_argumentrr<rPiis_Atomr as_coeff_Mulrrrrrr(sympy.functions.elementary.trigonometricr/r3 is_number) r>r?rFrrr+i_rHarg_r/rVyrs r)rIzarg.evals q  A!S!! F1I66a065LLL5LIIIIIIII c9 % % $S"-- - S ! ! CHQKB af 99!AD&LB { "3''4466GAt{ 100%)Y0001774 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 Tc6|}||SdSr$)rr>r?rs r)rIzconjugate.evalb$!!## ?J ?r,ctSr$)r6ras r)inversezconjugate.inversehsr,c:t|jddSrRrrras r)rzconjugate._eval_Absk49Q<$////r,c6t|jdSrZ transposerras r) _eval_adjointzconjugate._eval_adjointn1&&&r,c|jdSrZrras r)rzconjugate._eval_conjugateqy|r,c|jr*tt|jd|dS|jr+tt|jd|d SdSrR)rCr6rrr0rUs r)rWzconjugate._eval_derivativetsm 9 JZ ! a$GGGHH H ^ Jj1q4HHHIII I J Jr,c6t|jdSrZadjointrras r)_eval_transposezconjugate._eval_transposezty|$$$r,c&|jdjSrZr_ras r)rbzconjugate._eval_is_algebraic}rcr,N)rprqrrrsrvrwrIrIrrPrrWrYrbrxr,r)r6r64s**VN[ 000'''JJJ %%%)))))r,r6c:eZdZdZedZdZdZdZdS)rOa 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. c6|}||SdSr$)rYrFs r)rIztranspose.evalrGr,c6t|jdSrZr6rras r)rPztranspose._eval_adjointrQr,c6t|jdSrZrWras r)rztranspose._eval_conjugaterZr,c|jdSrZrSras r)rYztranspose._eval_transposerTr,N) rprqrrrsrwrIrPrrYrxr,r)rOrOsg&&P[ '''%%%r,rOcHeZdZdZedZdZdZdZd dZ dZ dS) rXa 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. c|}||S|}|t|SdSr$)rPrYr6rFs r)rIz adjoint.evalsF!! ?J!!## ?S>> ! ?r,c|jdSrZrSras r)rPzadjoint._eval_adjointrTr,c6t|jdSrZrNras r)rzadjoint._eval_conjugaterQr,c6t|jdSrZr_ras r)rYzadjoint._eval_transposerQr,Ncf||jd}d|z}|r d|d|d}|S)Nrz %s^{\dagger}z\left(z \right)^{})_printr)rMprinterrrr?texs r)_latexzadjoint._latexsGnnTYq\**#  7 7-0SS###6C r,cddlm}|j|jdg|R}|jr||dz}n||dz}|S)Nr) prettyFormu†+) sympy.printing.pretty.stringpictrnrir _use_unicode)rMrjrrnpforms r)_prettyzadjoint._prettysk??????ty|3d333   +::l333EE::c??*E r,r$) rprqrrrsrwrIrPrrYrlrsrxr,r)rXrXs4""["''''''r,rXc<eZdZdZdZdZedZdZdZ dS) 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 TFcddlm}|jrR||}|dtdz t dz tfvr)ddlm}|t |zt|zS|jr|j }n|g}g}g}g}|D]$}|j r||gz }|j r||gz }||gz }%t|t|krN|r#t||ztt|zS|r t||zSddlm}t||dzSdS)Nrr?rr+)$sympy.functions.elementary.complexesr?r6rrr+rabsrris_polarrr;rru) r>r?argumentarr+rr@rBr>s r)rIzpolar_lift.eval%syHHHHHH = 0#B aAs1ub)))LLLLLL y2s3xx// : 8DD5D " "C| "SE! "SE!SE! x==3t99 $ $ 3X02:c8n3M3MMM 3X022LLLLLLH~iill22 % $r,cB|jd|S)z. Careful! any evalf of polar numbers is flaky r)r _eval_evalf)rMprecs r)rzpolar_lift._eval_evalfIsy|''---r,c:t|jddSrRrKras r)rzpolar_lift._eval_AbsMrLr,N) rprqrrrsr{rrwrIrrrxr,r)rurusc##JHM!3!3[!3F...00000r,rucDeZdZdZedZedZdZdS)r1a 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  ddlm}m}|jr|j}n|g}d}|D]}|js|t |z }t||r#||j dz }O|j rX|j \}}||t|j z||t|j zzz }t|tr|t |jdz }dS|S)Nr)r+rr{)rr+rrrr{r?r5rr3runbranched_argumentrrzru) r>r}r+rrrurFrr<s r)_getunbranchedz periodic_argument._getunbranchedzs1IIIIIIII 9 7DD4D   A: c!ff$ Ay)) ae0022155  ++--Bb!4F"" S[[!1!1122 Az** c!&)nn, ttr,c|jsdS|tkr#t|trt |jSt|t r)|dtzkrt |jd|S|jrMd|jD}t|t|jkrt t||S| |}|dSddl m }m}|t||rdS|tkr|S|tkr>ddlm}|||z t$jz |z}||s||z SdSdS)Nrrc g|] }|j | Srx)r)r'rVs r)rz*periodic_argument.eval..s???Q?q???r,)atanr/ceiling)rrr5principal_branchr1rrurrr;rrr5rr/r:#sympy.functions.elementary.integersrrr) r>r}periodnewargsrurr/rrs r)rIzperiodic_argument.evals * 4 R<>+UD 9 9 4 R<<  R<< C C C C C C 6)AF233F:A55>> &!A~% < & &r,cV|j\}}|tkr3t|}||S||St|t|}ddlm}||||z tjz |zz |S)Nrr) rrr1rrrrrr)rMrrrruubrs r)rzperiodic_argument._eval_evalfsI 6 R<<*99!<>> 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 )r1rrws r)rrs& S" % %%r,c6eZdZdZdZdZedZdZdS)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 TFcZddlm}t|trt |jd|S|t kr|St|t }t||}||kr|ts|tst|}d}| t|}t|t }|tsN||kr|t||z z|z}n|}|j s#||s||dz}|S|j s|d} } n|j |j \} } g} | D]} | jr| | z} | | gz } t| } t| |} | trdS| jrt#| | ks| dkrt| dkrn| dkrh| dkr't%| t t'| |zSt |t| zt'| z|t%| zS| jrLt%| |dz kdks | |dz kr-| dkr%|| tzt%| zSdSdSdS)NrrxcNt|tst|S|Sr$)r5rru)exprs r)mrz!principal_branch.eval..mr s'!$//,%d+++ r,rxr{rT)rr+r5rurrrr1r:replacerr{rrrtupler6rrzr)rMrVrr+rbargplrresrHmothersr9r?s r)rIzprincipal_branch.evalsDDDDDD a $ $ 7#AF1Iv66 6 R<<H q" % % F++ ::bff%677:!233 AB   J++B"2r**B66*%% ::#)AtbyM2225CCC|(CGGI,>,>(99Q<<'C ~ 3bqAA!1>1>2DAq  A} Q1#  &MM6** 77$ % % 4 = M1!44;;"axxAGGQaxx1vv.sAw????#IIae$4$4S!W$>>>>>Ass1Q3xx,,T222r,N) rprqrrrsr{rrwrIrrxr,r)rrsT&&PHM1+1+[1+f33333r,rFcvddlm}|jr|S|jrst |St |t rsrt |S|jr|S|jr.|j fd|j D}rt |S|S|j rJ|j tjkr5| tjt|jdS|jr|j fd|j DSt ||rt|j}g}|j ddD]M}t|dd}t|dd} ||f| zN||ft)|zS|j fd |j DS) Nr)Integralc4g|]}t|dS)Tpause _polarifyr'r?lifts r)rz_polarify..Es(JJJ3iT666JJJr,Frc4g|]}t|dS)Frrrs r)rz_polarify..Ls(NNNs3E:::NNNr,r{)rrcbg|]+}t|trt|n|,S)r)r5r r)r'r?rrs r)rz_polarify..WsROOO?BJsD11;3E::::7:OOOr,)sympy.integrals.integralsrr{r6rur5rr3rrrrrrExp1rrr4functionr9r) eqrrrrrlimitslimitvarrests `` r)rr:s3222222 {  |E"~~"fPePP"~~ P P BGJJJJ"'JJJ K  !a==  Prw!&((wwqvyUCCCDDD  PrwNNNNbgNNNOO B ! ! Pd%888WQRR[ ) )EE!H5>>>CU122YT???D MM3&4- ( ( ( (x4'E&MM133rwOOOOOFHgOOOP Pr,Tc|rd}tt||}|s|Sd|jD}||}|d|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}) Fc<i|]}|t|jdS)T)polar)r name)r'rs r)rzpolarify..s) B B BQAuQV4((( B B Br,ci|]\}}|| Srxrx)r'rrs r)rzpolarify..s...A1...r,)rrrritems)rrrrepss r)polarifyr[szP  72;; % %B  B B"/ B B BD B ..... ..r,cnt|tr|jr|S|sddlm}m}t||r|t |jSt|tr4|jddtzkrt |jdS|j s0|j s)|j s"|j r6|jdvr d|jvs |jdvr|jfd|jDSt|t rt |jdS|jr9t |j}t |j|jo| }||zS|jr1t+|jddr|jfd |jDS|jfd |jDS) Nrr*r{r)z==z!=c0g|]}t|Srx _unpolarifyr'rVexponents_onlys r)rz_unpolarify..s#MMM[N;;MMMr,ruFc2g|]}t|Srxrrs r)rz_unpolarify..s5%QGGr,c2g|]}t|dSrorrs r)rz_unpolarify..s%KKKa[ND99KKKr,)r5r r3rrr+rrrrrr is_Boolean is_Relationalrel_oprrurrrr4getattr)rrrrr+expors ` r)rrs b% BJ ;IIIIIIII b) $ $ <3{26>::;; ; b* + + ; ad0B0Brwqz>:: : I O O&(m O   O \))a27ll --27MMMMRWMMMN N b* % % ;rwqz>:: : y26>2227N.Y /11Tz ~'"'<??rwW  27KKKK27KKK LLr,Nct|tr|St|}|"t||Sd}d}|rd}|r6d}t |||}||krd}|}t|tr|S|6ddlm}||ddtddiS)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 :func:`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) NTFrrxr{) r5boolr unpolarifyrrrr+ru)rrrchangedrrr+s r)rrs""d B "''$--(((G E "ne44 "99GB c4  J A@@@@@ 88YYq\\1jmmQ7 8 88r,)F)TF)NF)4 __future__r sympy.corerrrrrr r sympy.core.exprr sympy.core.exprtoolsr sympy.core.functionr rrrrrsympy.core.logicrrsympy.core.numbersrrrsympy.core.powerrsympy.core.relationalr(sympy.functions.elementary.miscellaneousr$sympy.functions.elementary.piecewiserrr<rrr?r6rOrXrur1rrrrrrrxr,r)rs""""""AAAAAAAAAAAAAAAAAA ------))))))))))))))))00000000(((((((((( $$$$$$999999::::::wwwwwwwwtuuuuuuuuvr5r5r5r5r5?r5r5r5jw(w(w(w(w(/w(w(w(tyCyCyCyCyC/yCyCyCxJ)J)J)J)J)J)J)J)Z66666666r;;;;;o;;;DR0R0R0R0R0R0R0R0jgKgKgKgKgKgKgKgKT&&&,f3f3f3f3f3f3f3f3RPPPPB////////dMMMMB&9&9&9&9&9&9r,