ЦiSSKJr SSKJrJrJrJrJrJ r J r SSK J r SSK Jr SSKJrJrJrJrJr SSKJrJr SSKJrJrJr SSKJr SS KJr SS K J!r! SS K"J#r# "S S \5r$"SS\5r%"SS\5r&"SS\5r'"SS\5r("SS\5r)"SS\5r*"SS\5r+"SS\5r,"SS\5r-S r."S!S"\5r/S(S#jr0S)S$jr1S(S%jr2S*S'jr3g&)+)Tuple)SAddMulsympifySymbolDummyBasic)Expr) factor_terms)Function DerivativeArgumentIndexError AppliedUndef expand_mul) fuzzy_notfuzzy_or)piIoo)Pow)Eq)sqrt) Piecewisect\rSrSr%Sr\\\S'SrSr Sr \ S5r SSjr SrSrS rS rS rS rS rg)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 U[RLa[R$U[RLa[R$UR(aU$UR(d[ U-R(a[R $UR(aUR5S$UR(a-[U[5(a[URS5$///pCn[R"U5nUHnUR![ 5nUb&UR(dUR#U5 M?MAUR%[ 5(d$UR(aUR#U5 MURUS9nU(aUR#US5 MUR#U5 M ['U5['U5:wa%SX#U45upn U"U 5[)U 5- U -$g)Nrignorec32# UH n[U6v M g7fNr.0xss c/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/functions/elementary/complexes.py re.eval..iM.L38.L)rNaNComplexInfinityis_extended_real is_imaginaryrZero is_Matrix as_real_imag is_Function isinstance conjugaterrr make_argsas_coefficientappendhaslenim clsargincludedrevertedexcludedrtermcoeff real_imagabcs r(evalre.evalDs !%%<55L A%% %55L  ! !J   !C%!9!966M ]]##%a( ( __C!;!;chhqk? ",.r2H==%D++A.$ 11 .2!)>)>OOD) !% 1 1 1 =I   ! 5 -!$4yCM)Mx8.LMa1v1~))*c &U[R4$)z6 Returns the real number with a zero imaginary part. rr1selfdeephintss r(r3re.as_real_imagm aff~rKc TUR(dURSR(a![[URSUSS95$UR(dURSR(a)[ *[ [URSUSS95-$gNrTevaluate)r/rrrr0rr<rOxs r(_eval_derivativere._eval_derivativet}  1!>!>j1q4@A A >>TYYq\662Z ! a$?@A A7rKc `URS[[URS5-- $Nr)rrr<rOr?kwargss r(_eval_rewrite_as_imre._eval_rewrite_as_im{s'yy|a499Q< 0000rKc4URSR$r^r is_algebraicrOs r(_eval_is_algebraicre._eval_is_algebraic~yy|(((rKcx[URSRURSR/5$r^)rrr0is_zerorfs r( _eval_is_zerore._eval_is_zeros.122DIIaL4H4HIJJrKcBURSR(aggNrTr is_finiterfs r(_eval_is_finitere._eval_is_finite 99Q< ! ! "rKcBURSR(aggrorprfs r(_eval_is_complexre._eval_is_complexrtrKNT)__name__ __module__ __qualname____firstlineno____doc__tTupler __annotations__r/ unbranched_singularities classmethodrIr3rZrargrlrrrv__static_attributes__rxrKr(rrs\'R ,JN&*&*PA1)KrKrct\rSrSr%Sr\\\S'SrSr Sr \ S5r SSjr SrSrS rS rS rS rS rg)r<as 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 rTc2U[RLa[R$U[RLa[R$UR(a[R$UR (d[ U-R(a [ *U-$UR(aUR5S$UR(a.[U[5(a[URS5*$///pCn[R"U5nUHnUR![ 5nUb7UR(dUR#U5 M?UR#U5 MRUR%[ 5(dUR(aMURUS9nU(aUR#US5 MUR#U5 M ['U5['U5:wa%SX#U45upn U"U 5[)U 5-U -$g)Nrr c32# UH n[U6v M g7fr#r$r%s r(r)im.eval..r+r,)rr-r.r/r1r0rr2r3r4r5r6r<rrr7r8r9r:r;rr=s r(rIim.evals !%%<55L A%% %55L  ! !66M   !C%!9!928O ]]##%a( ( __C!;!;sxx{O# #+-r2H==%D++A.$ 11 . .XXa[[(=(=(=!% 1 1 1 =I   ! 5 -!$4yCM)Mx8.LMa1v1~))*rKc &U[R4$)z3 Return the imaginary part with a zero real part. rMrNs r(r3im.as_real_imagrSrKc TUR(dURSR(a![[URSUSS95$UR(dURSR(a)[ *[ [URSUSS95-$grU)r/rr<rr0rrrXs r(rZim._eval_derivativer\rKc b[*URS[URS5- -$r^)rrrr_s r(_eval_rewrite_as_reim._eval_rewrite_as_res)r499Q<"TYYq\"2233rKc4URSR$r^rdrfs r(rgim._eval_is_algebraicrirKc4URSR$r^rr/rfs r(rlim._eval_is_zeroyy|,,,rKcBURSR(aggrorprfs r(rrim._eval_is_finitertrKcBURSR(aggrorprfs r(rvim._eval_is_complexrtrKrxNry)rzr{r|r}r~rr rr/rrrrIr3rZrrgrlrrrvrrxrKr(r<r<s['R ,JN%*%*NA4)-rKr<c^\rSrSrSrSrSrU4Sjr\S5r Sr Sr Sr S r S rS rS rS rSrSSjrSrSrSrSrSrU=r$)signi aR 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 >[TU]5nX :XaDURSRSLa(URS[ URS5- $U$)NrF)superdoitrrkAbs)rOrQs __class__s r(r sign.doitCsM GLN 91--699Q<#diil"33 3rKcUR(GaUR5up#/n[U5nUHnUR(aU*nMUR(aM,UR (aP[ U5nUR(a!U[-nUR(aU*nMxMzURU5 MURU5 M U[RLa[U5[U5:XagXP"UR"U65-$U[RLa[R$UR(a[R $UR(a[R$UR(a[R"$UR$(a['U[5(aU$UR (anUR((a#UR*[R,La[$[*U-nUR(a[$UR(a[*$ggr#)is_Mul as_coeff_mulris_extended_negativeis_extended_positiver0r< is_comparablerr9rOner; _new_rawargsr-rkr1 NegativeOner4r5is_PowexpHalf) r>r?rHrunkrrFaiarg2s r(rI sign.evalIs :::&&(GACQA))A++~~U++FA!66&'B 7  JJqM 1 #$AEEzc#h#d)3s3++S122 2 !%%<55L ;;66M  # #55L  # #== ??#t$$   zzcgg/28D((((r ) rKcr[URSR5(a[R$gr^)rrrkrrrfs r( _eval_Abssign._eval_Abs{s) TYYq\)) * *55L +rKcD[[URS55$r^)rr6rrfs r(_eval_conjugatesign._eval_conjugatesIdiil+,,rKchURSR(a7SSKJn S[ URSUSS9-U"URS5-$URSR (a?SSKJn S[ URSUSS9-U"[ *URS-5-$g)Nr) DiracDeltaTrV)rr/'sympy.functions.special.delta_functionsrrr0r)rOrYrs r(rZsign._eval_derivatives 99Q< ( ( Jz$))A,DAATYYq\*+ + YYq\ & & Jz$))A,DAAaR$))A,./0 0'rKcBURSR(aggro)ris_nonnegativerfs r(_eval_is_nonnegativesign._eval_is_nonnegative 99Q< & & 'rKcBURSR(aggro)ris_nonpositiverfs r(_eval_is_nonpositivesign._eval_is_nonpositiverrKc4URSR$r^)rr0rfs r(_eval_is_imaginarysign._eval_is_imaginaryrirKc4URSR$r^rrfs r(_eval_is_integersign._eval_is_integerrrKc4URSR$r^)rrkrfs r(rlsign._eval_is_zerosyy|###rKc[URSR5(a4UR(a"UR(a[ R $gggr^)rrrk is_integeris_evenrr)rOothers r( _eval_powersign._eval_powersC diil** + +    MM55L   ,rKcURSnURUS5nUS:waURU5$US:waURX5n[ U5S:a[ R *$[ R $r^)rsubsfuncdirrrr)rOrYnlogxcdirarg0x0s r( _eval_nseriessign._eval_nseriessgyy| YYq!_ 799R= 1988A$DDAv01550rKc TUR(a[SUS:4SUS:4S5$g)Nrr)rT)r/rr_s r(_eval_rewrite_as_Piecewisesign._eval_rewrite_as_Piecewises/   aq\Ba=)D D rKc NSSKJn UR(aU"U5S-S- $g)Nr Heavisiderrrrr/rOr?r`rs r(_eval_rewrite_as_Heavisidesign._eval_rewrite_as_Heavisides'E   S>A%) ) rKc N[S[US54U[U5- S45$ro)rrrr_s r(_eval_rewrite_as_Abssign._eval_rewrite_as_Abss&!RQZ3S>4*@AArKc PUR[URS55$r^)rr r)rOr`s r(_eval_simplifysign._eval_simplifysyydiil344rKrxr)rzr{r|r}r~ is_complexrrrrIrrrZrrrrrlrrrrrrr __classcell__)rs@r(rr s|4lJN //b-0)-$1E* B55rKrc\rSrSr%Sr\\\S'SrSr Sr Sr Sr SSjr \S5rSrS rS rS rS rS rSrSrSrSrSSjrSrSrSrSrSrSr g)ria 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 rTFcTUS:Xa[URS5$[X5e)z5 Get the first derivative of the argument to Abs(). rr)rrr)rOargindexs r(fdiff Abs.fdiffs) q= ! % %$T4 4rKc  ^^SSKJn [TS5(aTR5nUbU$[ T[ 5(d[ S[T5-5eU"TSS9mTR5upEUR(a"UR(dU"U5U"U5- $TR(Ga%/n/nTRHnUR(aURR(avURR(a[U"UR 5n [ X5(aUR#U5 MUR#[%XR55 MU"U5n [ X5(aUR#U5 MUR#U 5 M ['U6nU(a U"['U6SS9O[(R*nXg-$T[(R,La[(R,$T[(R.La[0$SSKJ n Jn TR(Ga%TR75upU R8(aUR(aDUR:(aT$U [(R<La[(R*$[?U 5U-$U R@(aU [CU5-$U RD(a)U *[CU5-U "[F*[IU5-5-$gU RK[L5(d9U "U 5RO5unnU[PU--nU "[CUU-55$[ TU 5(aU "[CTRS55$[ T[R5(a(TRT(aT$TR(aT*$gTRV(aTTRK[0[(RX5(a+[[STRO555(a[0$TR\(a[(R^$TR@(aT$TR`(aT*$TRb(a[P*T-nUR@(aU$TR8(agU"TRe5SS9mTRg[d5TRg[d5- nU(aU4S jU55(agTT:waTT*:waTRg[>5nTRkUVs0sH nU[mS S 9_M sn5nURVs/sHoR8bMUPM nnU(a[iU4S jU55(d[o[qTT-55$gggs snfs snf) Nr)signsimprzBad argument type for Abs(): %sFrV)rlogc38# UHoRv M g7fr#) is_infinite)r&rFs r(r)Abs.eval..Ps=*# UH#nTRURS5v M% g7f)rN)r:r)r&ir?s r(r)rbs%A1CGGAFF1I..s+.T)realc3X># UHnTR[U55v M! g7fr#)r:r6)r&uconjs r(r)rhs!!F#Q$((9Q<"8"8#s'*)9sympy.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_AddNegativeInfinityanyrkr1is_extended_nonpositiver0r6atomsallxreplacer rr)r>r?robjrdknownrtbnewtnewrrrexponentrFrGzrnew_conjr!r abs_free_argrs ` @r(rIAbs.eval s44 3 $ $--/C #t$$=S IJ JsU+!!# >>!..q6#a&= :::ECXX88 0 0QUU5F5Fqvv;D!$,, 1  Suu%56q6D!$,, 1  T*KE47#c3i%0QUUC9  !%%<55L !## #IC ::: __.ND$$&&''" q}}, uu t9h..//H--,,!EBxL0bSH5E1FFFXXf%%4y--/1!G2hqj>** c3  r#((1+' ' c< ( ( t  ::#''"a&8&899=#*:*:*<=== ;;66M  & &J  & &4K   28D++     %8::i(399Y+?? AAAA  $;34%<YYs^F<IIaL))!,Q/ ==Q !s1vt4I IIaL & &qD & 9Y!))++rKc4URSR(dURSR(a:[URSUSS9[ [ URS55-$[ URS5[[ URS5USS9-[URS5[[URS5USS9--[URS5- nUR[5$rU) rr/r0rrr6rr<rrewrite)rOrYrvs r(rZAbs._eval_derivatives 99Q< ( (DIIaL,E,EdiilA=y1./0 01Btyy|,>> 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. TcUn[S5HMn[X 5(aURSnM$US:Xa#UR(a[R s $ O [R $SSKJnJn [X5(a[U[5$[X5(ak[URS5nUR(aBUS[R--nU[R:aUS[R--nU$UR(dx[U5R!5upxUR"(a=[%URVs/sHn['U5S;aUO ['U5PM! sn6n['U5U-nOUn[)SUR+[,555(agSSKJn UR35upU "X5n U R4(aU $X:waU"USS 9$gs snf) Nrrr exp_polar)rrc3<# UHoRSLv M g7fr#)r)r&rs r(r)arg.eval.. sP7O!%%-7Osatan2FrV)ranger5rr/rr-rrr]periodic_argumentrr<rPiis_Atomr as_coeff_Mulrrrrrr(sympy.functions.elementary.trigonometricrar3 is_number) r>r?rFrrr]i_rHarg_rarYyrMs r(rIarg.evals qA!!!FF1I6a0055L 55LI c % %$S"- -  ! !CHHQKBaf 9!ADD&LB {{"3'446GA{{%)YY0%.$(7'#9QG%.0174>> 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 Tc.UR5nUbU$gr#)rr>r?rs r(rIconjugate.evalO!!# ?J rKc[$r#)r6rfs r(inverseconjugate.inverseUsrKc0[URSSS9$rUrrrfs r(rconjugate._eval_AbsX499Q<$//rKc2[URS5$r^ transposerrfs r( _eval_adjointconjugate._eval_adjoint[1&&rKc URS$r^rrfs r(rconjugate._eval_conjugate^yy|rKcUR(a![[URSUSS95$UR(a"[[URSUSS95*$grU)rrr6rrr0rXs r(rZconjugate._eval_derivativeasP 99Z ! a$GH H ^^j1q4HII IrKc2[URS5$r^adjointrrfs r(_eval_transposeconjugate._eval_transposegtyy|$$rKc4URSR$r^rdrfs r(rgconjugate._eval_is_algebraicjrirKrxN)rzr{r|r}r~rrrIryrrrrZrrgrrxrKr(r6r6!sE*VN 0'J %)rKr6c:\rSrSrSr\S5rSrSrSr Sr g) rina 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. c.UR5nUbU$gr#)rrus r(rItranspose.evalrwrKc2[URS5$r^r6rrfs r(rtranspose._eval_adjointrrKc2[URS5$r^rrfs r(rtranspose._eval_conjugaterrKc URS$r^rrfs r(rtranspose._eval_transposerrKrxN) rzr{r|r}r~rrIrrrrrxrKr(rrns+&P '%rKrcJ\rSrSrSr\S5rSrSrSr S Sjr S r S r g) riaq 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. cjUR5nUbU$UR5nUb [U5$gr#)rrr6rus r(rI adjoint.evals<! ?J!!# ?S> ! rKc URS$r^rrfs r(radjoint._eval_adjointrrKc2[URS5$r^rrfs r(radjoint._eval_conjugaterrKc2[URS5$r^rrfs r(radjoint._eval_transposerrKNcpURURS5nSU-nU(a SU<SU<S3nU$)Nrz %s^{\dagger}z\left(z \right)^{})_printr)rOprinterrrr?texs r(_latexadjoint._latexs4nnTYYq\*# -0#6C rKcSSKJn UR"URS/UQ76nUR(a XC"S5-nU$XC"S5-nU$)Nr) prettyFormu†+) sympy.printing.pretty.stringpictrrr _use_unicode)rOrrrpforms r(_prettyadjoint._prettysT?tyy|3d3   :l33E :c?*E rKrxr#) rzr{r|r}r~rrIrrrrrrrxrKr(rrs44""''rKrc<\rSrSrSrSrSr\S5rSr Sr Sr g ) polar_liftia2 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 TFcNSSKJn UR(aFU"U5nUS[S- [*S- [4;a!SSKJn U"[ U-5[U5-$UR(a URnOU/n/n/n/nUH8nUR(aXa/- nMUR(aX/- nM3Xq/- nM: [U5[U5:aKU(a[Xh-6[[U65-$U(a [Xh-6$SSKJn [U6U"S5-$g)Nrr?rr])$sympy.functions.elementary.complexesr?rhrrr]rabsrris_polarrr;rr) r>r?argumentarr]rr@rBpositives r(rIpolar_lift.evalsH ==#B aAs1ub))L 2s3x// ::88D5DC||E!E!E!  x=3t9 $X02:c8n3MMMX022LH~il22 %rKc>URSRU5$)z-Careful! any evalf of polar numbers is flaky r)r _eval_evalf)rOprecs r(rpolar_lift._eval_evalf6syy|''--rKc0[URSSS9$rUr|rfs r(rpolar_lift._eval_Abs:r~rKrxN) rzr{r|r}r~rrrrIrrrrxrKr(rrs1#JHM!3!3F.0rKrc>\rSrSrSr\S5r\S5rSrSr g)rci>aI 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 DSSKJnJn UR(a URnOU/nSnUHnUR (dU[ U5- nM$[Xb5(a!XVRR5S- nMUUR(aVURR5upxXW[UR5-X"[UR55--- nM[U[5(aU[ URS5- nM g U$)Nr)r]rr)rr]rrrrr?r5rr3runbranched_argumentrrr) r>rr]rrrrFrr<s r(_getunbranched periodic_argument._getunbranchedgsI 9977D4D A::c!f$ A))ee002155 ++-!4FF" S[!1122 Az**c!&&)n, rKc UR(dgU[:Xa'[U[5(a[ UR 6$[U[ 5(a&US[-:a[ UR SU5$UR(abUR Vs/sHo3R(aMUPM nn[U5[UR 5:wa[ [U6U5$URU5nUcgSSK JnJn UR![Xv5(agU[:XaU$U[:wa?SSKJn U"XR- [&R(- 5U-n U R!U5(dXY- $ggs snf)Nrr)atanraceiling)rrr5principal_branchrcrrrrrr;rrrgrrar:#sympy.functions.elementary.integersrrr) r>rperiodrYnewargsrrrarrs r(rIperiodic_argument.eval~s/ ** R>+U 9 9 R<  R< C )AFF23F:A55>>!~%" @s F6Fc0URup#U[:Xa+[RU5nUcU$UR U5$[U[5R U5nSSKJn XV"XS- [R- 5U-- R U5$)Nrr) rrrcrrrrrr)rOrr"rrubrs r(rperiodic_argument._eval_evalfsII  R<*99!s6&P,&&: KrKrcc"[U[5$)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 )rcrrs r(rrs& S" %%rKc6\rSrSrSrSrSr\S5rSr Sr g) riaZ 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 SSKJn [U[5(a[ UR SU5$U[ :XaU$[U[ 5n[X5nXE:waUR[5(dUR[5(d[U5nSnUR[U5n[U[ 5nUR[5(dOXE:waU"[XT- -5U-nOUnUR(d URU5(d X"S5-nU$UR(dUSpOUR"UR6up/n U Hn U R(aX-n MX/- n M! [U 5n [X5n U R[5(agU R (as[#U 5U :wdU S:Xa^U S:waXU S:waRU S:Xa[%U 5[ ['U 6U5-$[ U"[U -5['U 6-U5[%U 5-$U R (a@[%U 5US- :S:XdXS- :Xa"U S:XaU"U [-5[%U 5-$ggg)NrrcF[U[5(d [U5$U$r#)r5rr)exprs r(mr!principal_branch.eval..mrs!$//%d++ rKrxrrT)rr]r5rrrrrcr:replacerrr rrtuplerhrrr)rOrYrr]rbargplrresrHmothersrkr?s r(rIprincipal_branch.evals D a $ $#AFF1Iv6 6 R<H q" % + :bff%677!233AB J+B"2r*B66*%%:#AtyM225CC||CGGI,>,>9Q<'C ~~bq>>1>>2DAA}}#   &M* 77$ % % ==1!4;"axAGQax1v.sAw???#Iae$4S!W$As1Q3x,,T22rKrxN) rzr{r|r}r~rrrrIrrrxrKr(rrs,&PHM1+1+f3rKrc SSKJn UR(aU$UR(aU(d [ U5$[ U[ 5(aU(dU(a [ U5$UR(aU$UR(aFUR"URVs/sH n[XASS9PM sn6nU(a [ U5$U$UR(aQUR[R:Xa3UR[R[UR USS95$UR"(a2UR"URVs/sH n[XASS9PM sn6$[ X5(an[UR$XS9n/nURSSH3n[USSUS9n [USSXS9n UR'U 4U -5 M5 U"U4[)U5-6$UR"URVs/sH$n[ U[*5(a [XAUS9OUPM& sn6$s snfs snfs snf)Nr)IntegralT)pauseFr)liftr)sympy.integrals.integralsrrrhrr5rrerrr _polarifyrrrExp1rr4functionr9rr ) eqrrrr?rrlimitslimitvarrests r(rr's2 {{  ||E"~"fe"~   GG"''J'3i6'J K a=  rww!&&(wwqvvyUCDD wwbggNgs3E:gNOO B ! !d8WWQR[EE!H5>CU12YT?D MM3&4- (!4'E&M133wwFHggOFMsJsD11#3E:7:;FMOP P%KOOs)I"I+I c 0U(aSn[[U5U5nU(dU$URVs0sHo3[URSS9_M nnUR U5nXR 5VVs0sHup5XS_M snn4$s snfs snnf)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}) FT)polar)rrr r nameritems)rrrrrepsrs r(polarifyrHsP  72; %B  24// B/QuQVV4( (/D B B .. .. C.s B :Bc  [U[5(aUR(aU$U(GdQSSKJnJn [X5(aU"[ URU55$[U[5(a3URSS[-:Xa[ URSU5$UR(dcUR(dRUR(dAUR(acURS;aSUR;dURS;a3UR"URVs/sHn[ XQ5PM sn6$[U[ 5(a[ URSU5$UR"(aN[ URU5n[ UR$UUR&=(a U(+(+5nXv-$UR((aP[+URSS5(a4UR"URVs/sHn[ XQU5PM sn6$UR"URVs/sHn[ XQS5PM sn6$s snfs snfs snf) Nrr\rr)z==z!=rFT)r5r rerrr] _unpolarifyrrrrr is_Boolean is_Relationalrel_oprrrrrr4getattr)rexponents_onlyrrr]rYexpors r(rrzs b% BJJ I b $ ${266>:; ; b* + + ad0Brwwqz>: : IIbmm    \)a277l -77RWWMW[;WMN N b* % %rwwqz>: : yy266>2277N.Y /1z ~~'"''<??wwWW%QG  77277K7a[D97K LLNLs;I6(I;JNcj[U[5(aU$[U5nUb[UR U55$SnSnU(aSnU(a7Sn[ XU5nXP:waSnUn[U[5(aU$U(aM7SSKJn WR U"S5S[S5S05$)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) TFrrr) r5boolr unpolarifyrrrr]r)rrrchangedrrr]s r(rrs""d B "''$-((G E "e4 9GB c4 J 'A 88Yq\1jmQ7 88rK)F)TF)NF)4typingrr sympy.corerrrrrr r sympy.core.exprr sympy.core.exprtoolsr sympy.core.functionr rrrrsympy.core.logicrrsympy.core.numbersrrrsympy.core.powerrsympy.core.relationalr(sympy.functions.elementary.miscellaneousr$sympy.functions.elementary.piecewiserrr<rrr?r6rrrrcrrrrrrrxrKr(rs"AAA -0(( $9:wwtuuvr58r5jw((w(tf(fRJ)J)Z66r;h;DR0R0jgKgKT&,f3xf3RPB//dMB&9rK