\h&SrSSKJrJr SSKJr SSKJrJr SSK J r SSK J r J r JrJrJr SSKJr SSKJrJr SS KJr SS KJr SS KJr SS KJrJr SS KJ r J!r!J"r" SSK#J$r$J%r% SSK&J'r'J(r(J)r)J*r* SSK+J,r, SSK-J.r.J/r/J0r0 SSK1J2r2 SSK3J4r4J5r5J6r6J7r7 SSK8J9r9 SSK:J;r; SSKJ?r? SSK@JArAJBrB SSKCJDrD SSKEJFrFJGrGJHrHJIrIJJrJ SSKKJLrL SSKMJNrNJOrO SSKPJQrQ SSKRJSrS SSKTJUrU "S S!\V5rW"S"S#\5rXS$rYS%rZ\Z"S&5r[S'r\\[\\S(4S)j5r]"S*S+\X5r^S,r_S-r`"S.S/\a5rbS0rc\Z"S(5SWS1j5rdS2qe"S3S4\X5rfS5rg\Z"S(5SXS6j5rh"S7S8\X5ri"S9S:\i5rjS;rk"S<S=\i5rlS>rm\Z"S(5SXS?j5rn"S@SA\X5ro"SBSC\o5rpSDrq"SESF\o5rrSGrs"SHSI\o5rtSJru"SKSL\o5rvSMrw\Z"S(5SXSNj5rx"SOSP\X5ry"SQSR\y5rzSSr{"STSU\y5r|SVr}SS2K~Js Jr \GRr\GRr\GRr\GR r\GR r\GRrg2)YzIntegral Transforms )reducewraps)repeat)Spi)Add) AppliedUndef count_opsexpand expand_mulFunction)Mul)igcdilcm)default_sort_key)Dummy)postorder_traversal) factorialrf)reargAbs)exp exp_polar)coshcothsinhtanh)ceiling)MaxMinsqrt)piecewise_fold)coscotsintan)besselj) Heaviside)gamma)meijerg) integrateIntegral)_dummy)to_cnf conjuncts disjunctsOrAnd)roots)factorPoly)CRootOf)iterable)debugc,^\rSrSrSrU4SjrSrU=r$)IntegralTransformError(av Exception raised in relation to problems computing transforms. Explanation =========== This class is mostly used internally; if integrals cannot be computed objects representing unevaluated transforms are usually returned. The hint ``needeval=True`` can be used to disable returning transform objects, and instead raise this exception if an integral cannot be computed. c@>[TU]U<SU<S35 X lg)Nz" Transform could not be computed: .)super__init__function)self transformrAmsg __class__s R/var/www/auris/envauris/lib/python3.13/site-packages/sympy/integrals/transforms.pyr@IntegralTransformError.__init__6s 9BC H J )rA)__name__ __module__ __qualname____firstlineno____doc__r@__static_attributes__ __classcell__)rEs@rFr;r;(s !!rHr;c\rSrSrSr\S5r\S5r\S5r\S5r Sr Sr S r S r S r\S 5rS rSrg)IntegralTransform<aE Base class for integral transforms. Explanation =========== This class represents unevaluated transforms. To implement a concrete transform, derive from this class and implement the ``_compute_transform(f, x, s, **hints)`` and ``_as_integral(f, x, s)`` functions. If the transform cannot be computed, raise :obj:`IntegralTransformError`. Also set ``cls._name``. For instance, >>> from sympy import LaplaceTransform >>> LaplaceTransform._name 'Laplace' Implement ``self._collapse_extra`` if your function returns more than just a number and possibly a convergence condition. c URS$)z The function to be transformed. rargsrBs rFrAIntegralTransform.functionSyy|rHc URS$)z:The dependent variable of the function to be transformed. rTrVs rFfunction_variable#IntegralTransform.function_variableXrXrHc URS$)z$The independent transform variable. rTrVs rFtransform_variable$IntegralTransform.transform_variable]rXrHc~URRRUR15UR1- $)zR This method returns the symbols that will exist when the transform is evaluated. )rA free_symbolsunionr_r[rVs rFrbIntegralTransform.free_symbolsbs; }}))//1H1H0IJ%%&' 'rHc [eNNotImplementedErrorrBfxshintss rF_compute_transform$IntegralTransform._compute_transformk!!rHc[erfrgrBrjrkrls rF _as_integralIntegralTransform._as_integralnrprHcd[U6nUS:Xa![URRSS5eU$)NF)r3r;rEname)rBextraconds rF_collapse_extra!IntegralTransform._collapse_extraqs0E{ 5=()<)# UH nURTR5v M" g7frf)hasr[).0funcrBs rF 2IntegralTransform._try_directly..ys+N+L4 $xx(>(>??+Ls(+z6[IT _try ] Caught IntegralTransformError, returns None) anyrAatomsr rnr[r_r;r9is_Addr )rBrmT try_directlyfns` rF _try_directlyIntegralTransform._try_directlyws N+/==+>+>|+LNNN  ++DMM**D,C,CNGLN ]]yyBBu * NO s3B!!B;:B;c 2URSS5nURSS5nX1S'UR"S 0UD6upEUbU$UR(Ga0X!S'URVs/sH<nUR"U/[ URSS5-6R "S 0UD6PM> nn/n/n UHmn[U[5(dU/nU RUS5 [U5S:XaURUS5 MT[U5S:dMeXSS/- nMo US:Xa[U 6R5nO[U 6nU(dU$URU5n[U5(aU4[U5-$Xx4$U(a+[URR UR"S5eUR%UR&5upXR"[)U 6/[ URSS5-6-$s snf![a Nf=f) a] Try to evaluate the transform in closed form. Explanation =========== This general function handles linearity, but apart from that leaves pretty much everything to _compute_transform. Standard hints are the following: - ``simplify``: whether or not to simplify the result - ``noconds``: if True, do not return convergence conditions - ``needeval``: if True, raise IntegralTransformError instead of returning IntegralTransform objects The default values of these hints depend on the concrete transform, usually the default is ``(simplify, noconds, needeval) = (True, False, False)``. needevalFsimplifyTNrZrr^)poprrrUrElistdoit isinstancetupleappendlenrrrzr8r;_namerA as_coeff_mulr[r) rBrmrrrrrkresrxresscoeffrests rFrIntegralTransform.doits*99Z/99Z.$j""+U+ =H 999 (* GG%#q>>QC$tyy}*=$=?DDMuM# %ED!!U++A AaD!q6Q;LL1&VaZeW$E~4j))+4j  ,,U3E??6E%L00<' ($$dmmZA A ood&<&<= ^^sDzlT$))AB-5H&HJJJK%4*  s&AH/H H HHcdURURURUR5$rf)rsrAr[r_rVs rF as_integralIntegralTransform.as_integrals,  0F0F!%!8!8: :rHcUR$rf)r)rBrUkwargss rF_eval_rewrite_as_Integral+IntegralTransform._eval_rewrite_as_IntegralsrHrN)rIrJrKrLrMpropertyrAr[r_rbrnrsrzrrrrrNrrHrFrQrQ<s,''"" "EKN:: rHrQcXU(a"SSKJn SSKJn U"U"[ U5SS95$U$)Nr)r) powdenestT)polar)sympy.simplifyrsympy.simplify.powsimprr#)exprrrrs rF _simplifyrs' +4 ."6dCDD KrHc^U4SjnU$)a& This is a decorator generator for dropping convergence conditions. Explanation =========== Suppose you define a function ``transform(*args)`` which returns a tuple of the form ``(result, cond1, cond2, ...)``. Decorating it ``@_noconds_(default)`` will add a new keyword argument ``noconds`` to it. If ``noconds=True``, the return value will be altered to be only ``result``, whereas if ``noconds=False`` the return value will not be altered. The default value of the ``noconds`` keyword will be ``default`` (i.e. the argument of this function). c:>^[T5TS.U4Sjj5nU$)Nnocondsc0>T"U0UD6nU(aUS$U$Nrr)rrUrrrs rFwrapper0_noconds_..make_wrapper..wrappers#''C1v JrH)r)rrdefaults` rF make_wrapper_noconds_..make_wrappers# t#*    rHr)rrs` rF _noconds_rs$ rHFcV[X[R[R45$rf)r,rZeroInfinity)rjrks rF_default_integratorrs QAFFAJJ/ 00rHTc^ [SSU5m U"UT S- -U-U5nUR[5(dK[UR T U5U5[ R [ R4[ R4$UR(d [SUS5eURSupVUR[5(a [SUS5eU 4Sjn[U5Vs/sH o"U5PM n nU Vs/sHoS S :wdM UPM n nU RS S 9 U (d [SUS 5eU Supn [UR T U5U5X4U 4$s snfs snf)z/Backend function to compute Mellin transforms. rlzmellin-transformrZMellincould not compute integralrintegral in unexpected formc>SSKJn [Rn[Rn[R n[ [U55n[SSS9nUGHn[Rn[Rn /n [U5Hn U R[S5R[T5U5n U R(a<U RS;d,U RT5(dU RU5(dX/- n MU"X5n U R(aU RS;aX/- n MU R U:Xa[#U R$U 5n M['U R U5nM U[RLaX:wa[#X5nGMPU [RLaX:wa['X5nGMv[)U[+U 65nGM X#U4$)z> Turn ``cond`` into a strip (a, b), and auxiliary conditions. r)_solve_inequalitytT)realc(UR5S$r) as_real_imagrks rF:_mellin_transform..process_conds..)s!.."21"5rH)z==z!=)sympy.solvers.inequalitiesrrNegativeInfinityrtruer0r/rr1replacersubs is_Relationalrel_opr~ltsr gtsr!r3r2)ryrabauxcondsrca_b_aux_dd_solnrls rF process_conds(_mellin_transform..process_condssw A   JJff&,' #D !AB##BDq\YY577;tBqE1~HH ,66!99BFF1IICKD(/)) |3CKD88q=TXXr*BTXXr*B!""#J1---"'J#r4y)56SyrHr^Fc4USUS- [US54$)NrrZr^)r rs rFr#_mellin_transform..BsadQqTk9QqT?;rHkeyzno convergence found)r.r~r-rrrrrr is_Piecewiser;rUr1sort)rjrks_ integratorrFryrrrrrrrls @rF_mellin_transformrsM s&*A1q1u:>1%A 55??21A4F4F 3SUVU[U[[[ >>$Xq2NOOffQiGAuuX$ a68 8%N(1 7!]1 E 7 /11QE / JJ;J< $Xq2HIIaIA# QVVAr]H -vs :: 8 /s/E* E/E/c.\rSrSrSrSrSrSrSrSr g) MellinTransformiKz Class representing unevaluated Mellin transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute Mellin transforms, see the :func:`mellin_transform` docstring. rc [XU40UD6$rf)rris rFrn"MellinTransform._compute_transformWs q2E22rHch[XUS- --U[R[R45$NrZ)r-rrrrrs rFrsMellinTransform._as_integralZs(a!e* q!&&!**&=>>rHc/n/n/nUHuupVnX%/- nX6/- nXG/- nM [U6[U64[U64nUSSUSS:S:Xd USS:Xa [SSS5eU$)NrrZTFrzno combined convergence.)r r!r3r;) rBrxrrrysasbrrs rFrzMellinTransform._collapse_extra]s   KHRa IA IA CKD!AwQ #t*, F1IQ "t +s1v($ :< < rHrN) rIrJrKrLrMrrnrsrzrNrrHrFrrKs E3? rHrc :[XU5R"S0UD6$)a Compute the Mellin transform `F(s)` of `f(x)`, .. math :: F(s) = \int_0^\infty x^{s-1} f(x) \mathrm{d}x. For all "sensible" functions, this converges absolutely in a strip `a < \operatorname{Re}(s) < b`. Explanation =========== The Mellin transform is related via change of variables to the Fourier transform, and also to the (bilateral) Laplace transform. This function returns ``(F, (a, b), cond)`` where ``F`` is the Mellin transform of ``f``, ``(a, b)`` is the fundamental strip (as above), and ``cond`` are auxiliary convergence conditions. If the integral cannot be computed in closed form, this function returns an unevaluated :class:`MellinTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. If ``noconds=False``, then only `F` will be returned (i.e. not ``cond``, and also not the strip ``(a, b)``). Examples ======== >>> from sympy import mellin_transform, exp >>> from sympy.abc import x, s >>> mellin_transform(exp(-x), x, s) (gamma(s), (0, oo), True) See Also ======== inverse_mellin_transform, laplace_transform, fourier_transform hankel_transform, inverse_hankel_transform r)rr)rjrkrlrms rFmellin_transformrls R 1 # ( ( 15 11rHcUupE[U[- 5n[U[- 5n[U*U-UR5S- 5n[ XA-U-U-5[ SU- U- XA-- 5SU-[-4$)a, Re-write the sine function ``sin(m*s + n)`` as gamma functions, compatible with the strip (a, b). Return ``(gamma1, gamma2, fac)`` so that ``f == fac/(gamma1 * gamma2)``. Examples ======== >>> from sympy.integrals.transforms import _rewrite_sin >>> from sympy import pi, S >>> from sympy.abc import s >>> _rewrite_sin((pi, 0), s, 0, 1) (gamma(s), gamma(1 - s), pi) >>> _rewrite_sin((pi, 0), s, 1, 0) (gamma(s - 1), gamma(2 - s), -pi) >>> _rewrite_sin((pi, 0), s, -1, 0) (gamma(s + 1), gamma(-s), -pi) >>> _rewrite_sin((pi, pi/2), s, S(1)/2, S(3)/2) (gamma(s - 1/2), gamma(3/2 - s), -pi) >>> _rewrite_sin((pi, pi), s, 0, 1) (gamma(s), gamma(1 - s), -pi) >>> _rewrite_sin((2*pi, 0), s, 0, S(1)/2) (gamma(2*s), gamma(1 - 2*s), pi) >>> _rewrite_sin((2*pi, 0), s, S(1)/2, 1) (gamma(2*s - 1), gamma(2 - 2*s), -pi) rrZ)r rrrr*)m_nrlrrmnrs rF _rewrite_sinrsJ DA1R4A1R4A1q~~'**+A q1 uQUQY_5Qwrz AArHc\rSrSrSrSrg)MellinTransformStripErroriz> Exception raised by _rewrite_gamma. Mainly for internal use. rN)rIrJrKrLrMrNrrHrFrrs  rHrc (^^^/^0^1^2[X#/5um/m0U/U04Sjn/nTR[5HinURT5(dMURSnUR (aUR "T5SnUR"T5upXX/- nMk TR[[[[5HpnURT5(dMURSnUR (aUR "T5SnUR"T5upXX[- /- nMr UV s/sH oR(a [U 5OU PM" nn [Rn UHn U R (aMU n O UV s/sHoU - PM nn [#SU55(aU R(d [%SSS5eU ['[(UV s/sHn [U R*5PM sn [R5- n X:XaI[-U5S:XaU n O7U ['[.UV s/sHn [U R05PM sn 5-n TR3TTU - 5m[RU - n [RU - nT/bT/U -m/T0bT0U -m0TR55unn[6R8"U5n[6R8"U5n[;[=U[?S555[;[=U[?S 555-n/n/n/n/n/nU4S jm1U(GagURA5um2nU(aUUnnUnOUUnnUnU1U2U4S jnT2RT5(dUT2/- nGOT2RB(d[ET2[F5(aT2RB(aT2RHnT2RFnO[KS5nT2RFnURL(a%UnUS:aU(+nUUU4/[U5-- nMURT5(d*U"U5up#U(dSU- nUUU-/- nUUU-/- nGO3T1"T25eT2ROT5(Ga-[QT2T5nURS5S:wavURU5Sn[WUT5n [-U 5URS5:wa[XRZ"U5n UU/- nUU V!s/sH n!TU!- U4PM sn!- nGMUR]5unn!UU/- nU!U*-n!U"U!U5(a3U[RU!*S-4/- nU[RU!*4/- nGOUS /- nU[R^U!S-4/- nU[R^U!4/- nGO[ET2[5(a`U"T2RS5up#U(a9US:aU"U*U- U5S :XdUS:aU"U*U- U5S:Xa [aS 5eUX#4/- nGOr[ET2[5(axT2RSnU(a.[U[- 5[SU[- - 5[n$n#n"O[cU"U5TT/T05un"n#n$UU"U(+4U#U(+4/- nUU$/- nO[ET2[5(a:T2RSnU[US S9U4[[S- U- S S9U(+4/- nO[ET2[5(a*T2RSnU[[S- U- S S9U4/- nOW[ET2[5(a:T2RSnU[[S- U- S S9U4[US S9U(+4/- nOT1"T25eU(aGMgU [7U6[7U6- -n ////4un%n&n'n(UU%U'S4UU(U&S 44GH6un)n*n+nU)(dMU)RA5unn!US :waUS:wa[[U55nUU- n,U!U- n-URL(d [eS5e[gU5Hn.U)U,U-U.U- -4/- n)M U(a6U S[-SU- S- -UU![Rh- ---n UUU-/- nO6U S[-SU- S- -UU![Rh- ---n UUU*-/- nMUS:XaU*RkSU!- 5 OU+RkU!5 U)(aGM$GM9 [7U6nU%Rm[nS9 U&Rm[nS9 U'Rm[nS9 U(Rm[nS9 U%U&4U'U(4X~U 4$s sn fs sn fs sn fs sn fs sn!f)a8 Try to rewrite the product f(s) as a product of gamma functions, so that the inverse Mellin transform of f can be expressed as a meijer G function. Explanation =========== Return (an, ap), (bm, bq), arg, exp, fac such that G((an, ap), (bm, bq), arg/z**exp)*fac is the inverse Mellin transform of f(s). Raises IntegralTransformError or MellinTransformStripError on failure. It is asserted that f has no poles in the fundamental strip designated by (a, b). One of a and b is allowed to be None. The fundamental strip is important, because it determines the inversion contour. This function can handle exponentials, linear factors, trigonometric functions. This is a helper function for inverse_mellin_transform that will not attempt any transformations on f. Examples ======== >>> from sympy.integrals.transforms import _rewrite_gamma >>> from sympy.abc import s >>> from sympy import oo >>> _rewrite_gamma(s*(s+3)*(s-1), s, -oo, oo) (([], [-3, 0, 1]), ([-2, 1, 2], []), 1, 1, -1) >>> _rewrite_gamma((s-1)**2, s, -oo, oo) (([], [1, 1]), ([2, 2], []), 1, 1, 1) Importance of the fundamental strip: >>> _rewrite_gamma(1/s, s, 0, oo) (([1], []), ([], [0]), 1, 1, 1) >>> _rewrite_gamma(1/s, s, None, oo) (([1], []), ([], [0]), 1, 1, 1) >>> _rewrite_gamma(1/s, s, 0, None) (([1], []), ([], [0]), 1, 1, 1) >>> _rewrite_gamma(1/s, s, -oo, 0) (([], [1]), ([0], []), 1, 1, -1) >>> _rewrite_gamma(1/s, s, None, 0) (([], [1]), ([0], []), 1, 1, -1) >>> _rewrite_gamma(1/s, s, -oo, None) (([], [1]), ([0], []), 1, 1, -1) >>> _rewrite_gamma(2**(-s+3), s, -oo, oo) (([], []), ([], []), 1/2, 1, 8) c0>[[U55nTcT[RLagTcUT:$TcUT:*$UT:S:XagUT:*S:XagU(agTR(d"TR(dUR(ag[ S5e)zE Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)r rrrrbr)ris_numerrrs rFleft_rewrite_gamma..left s 2a5M :" * :r6M :7N G  G   ??boo((EFFrHrrZc38# UHoRv M g7frf) is_Rational)rrks rFr!_rewrite_gamma..?s5}! }sGammaNzNonrational multiplierTFc$>[STSU-5$)NInverse MellinzUnrecognised form '%s'.)r;)factrjs rF exception!_rewrite_gamma..exceptionas%&6;TW[;[\\rHc>UR"T5(dT"T5e[UT5nUR5S:waT"T5eUR5$)z6Test if arg is of form a*s+b, raise exception if not. rZ) is_polynomialr6degree all_coeffs)rpr r rls rF linear_arg"_rewrite_gamma..linear_arglsL$$Q''o%S! AxxzQo%<<> !rHrz Gammas partially over the strip.)evaluater^za is not an integerr)8rrr*r~rUras_independentrr&r$r'r%ris_extended_realrOnerallr;rrqrrrras_numer_denomr make_argsrziprris_Powrrbaser is_Integerrr6rLTr4r7 all_rootsr NegativeOnerhr TypeErrorrangeHalfrrr)3rjrlrrr s_multipliersgrr_rkcommon_coefficient s_multiplierfacexponentnumerdenomrUfacsdfacs numer_gammas denom_gammas exponentialsrugammaslgammasufacsrrexp_ryrrsrgamma1gamma2fac_anapbmbqgammasplusminusnewanewckrrr r s3`` @@@@rF_rewrite_gammarFs ~vYFBG4M WWU^uuQxx ffQi ::$$Q'*C##A& WWS#sC (uuQxx ffQi ::$$Q'*C##A&(# )CPP-Q11SVq8-MP }}}!"  4AA=a))=MA 5}5 5 5  / /$Wd4LMM%fT6C4E6C56accF6C4EFGee'MML) }  "-L-}=}!qv}=>?L q!L.!A %% Cuu\!H ~ l ~ l##%LE5 MM% E MM% E E6$<( )DUF5M1J,K KD D ELLL] h +\WGE+\WGE "xx{{ dVOE [[JtS11{{yyxx |xx!8#8D$s4y00XXa[[!$'T6Dq ) q !o%    " "T1 AxxzQq 1a[r7ahhj( **1-B% B7Bq!a%*B77<<>DAq aSLE !GAAx  QUUQBFO,,QUUQBK=(" Q]]AE233Q]]A.// e $ $diil+DAEtQBqD(3u<EtQBqD(3t;-:<< x G c " "  ! A',QrT{E!ad(OR'3JqM1b"'M$ f(l+f(l-CD DD dVOE c " " ! A c!e,h7"Q$(U3\BD DD c " " ! A c"Q$(U3X>? ?D c " " ! A c"Q$(U3X>!e,(l;= =DD/ !M $P3:c5k !!CR^NBB+7R*F+7R*G*I%eXf::b8s='e;f,f f fc  [SSUSS9nUR[5n[U5[ U5[ U54GHnnUR (aURVs/sHn[XqXSUSS9PM nnUV s/sHoSPM n n UV s/sHoSPM nn [U6n U(d[XR[5S 9n U RXR5[U 64s $[XaUSUS5uppn[!XXU-- 5nU(aUnOSS KJn U"U5nUR*(a[-UR5S :Xai[U[/U5- 5URSRS-[[/U5U- 5URSRS--n[/[1UR255UR4[6-:/nU[[9[-UR:5[-UR<5:gS[?UR@5S-:5[/[1UR255UR4[6-:H5/- n[9U6nUS:Xa [S US5eUU-RXR5U4s $ [S US5es snfs sn fs sn f![a GMf=f!["a GMf=f![(a [S US 5ef=f)zjA helper for the real inverse_mellin_transform function, this one here assumes x to be real and positive. rzinverse-mellin-transformT)positiveFrrZr)gens) hyperexpandr zCould not calculate integralzdoes not convergerv)!r.rewriter*r5r r rrU_inverse_mellin_transformrrr)rr3rFr;r+ ValueErrorrrJrhrrrrargumentdeltarr2r=r?rnu)rrlx_strip as_meijergrkr'GrrrrrrCer+hrJrys rFrMrMs s.DAA %AQiAq 2 88VV%#.aAj6;=# %$((4aqT4E("&'$QaD$D't*CSyy';<88A?CK/ / ,Q58U1XFOA! a1f%A A I6N ~~#aff+"2a#a&j)!&&)..*;;A +AFF1INN1,==> C O$qwwrz12 RADD SY.RX\0ABQZZ)QWWRZ79: :4y 5=( !%8: :#||A"D((_3b !!11b 99]%)'&      ' I,$a)GII IsB%KKK ,KK# K5 K K # K21K25L Nc^\rSrSrSrSr\"S5r\"S5rSr \ S5r Sr S r S rg ) InverseMellinTransformi5z Class representing unevaluated inverse Mellin transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse Mellin transforms, see the :func:`inverse_mellin_transform` docstring. r Nonerc Uc[RnUc[Rn[R"XX#XE40UD6$rf)rZ_none_sentinelrQ__new__)clsrrlrkrroptss rFr^InverseMellinTransform.__new__Cs< 9&55A 9&55A ((qDtDDrHcURSURSp!U[RLaSnU[RLaSnX4$)NrK)rUrZr])rBrrs rFfundamental_strip(InverseMellinTransform.fundamental_stripJsHyy|TYYq\1 &55 5A &55 5At rHc URSS5 [c>[[[[ [ [[[[[[[1 q[U5HRnUR(dMUR!U5(dM.UR"[;dMD[%SUSU-5e UR&n[)XX640UD6$)NrTr zComponent %s not recognised.)r_allowedrr*r&r$r'r%rrrrrrr is_Functionr~rr;rdrM)rBrrlrkrmrjrSs rFrn)InverseMellinTransform._compute_transformSs  *d#  UCc3dD$2H%Q'A}}}qaffH.D,-=q%Ca%GII(&&(qA5AArHc(URRn[XU*--X$[R[R -- U[R[R --45S[R -[R-- $Nr^)rE_cr-r ImaginaryUnitrPi)rBrrlrkrs rFrs#InverseMellinTransform._as_integralcsv NN  qb' A1??1::+E'Eq$%OOAJJ$>H?$@ABCADD&BXZ ZrHrN)rIrJrKrLrMrrr]rlr^rrdrnrsrNrrHrFrZrZ5sF E6]N sBEB ZrHrZc H[XX#SUS5R"S0UD6$)a Compute the inverse Mellin transform of `F(s)` over the fundamental strip given by ``strip=(a, b)``. Explanation =========== This can be defined as .. math:: f(x) = \frac{1}{2\pi i} \int_{c - i\infty}^{c + i\infty} x^{-s} F(s) \mathrm{d}s, for any `c` in the fundamental strip. Under certain regularity conditions on `F` and/or `f`, this recovers `f` from its Mellin transform `F` (and vice versa), for positive real `x`. One of `a` or `b` may be passed as ``None``; a suitable `c` will be inferred. If the integral cannot be computed in closed form, this function returns an unevaluated :class:`InverseMellinTransform` object. Note that this function will assume x to be positive and real, regardless of the SymPy assumptions! For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Examples ======== >>> from sympy import inverse_mellin_transform, oo, gamma >>> from sympy.abc import x, s >>> inverse_mellin_transform(gamma(s), s, x, (0, oo)) exp(-x) The fundamental strip matters: >>> f = 1/(s**2 - 1) >>> inverse_mellin_transform(f, s, x, (-oo, -1)) x*(1 - 1/x**2)*Heaviside(x - 1)/2 >>> inverse_mellin_transform(f, s, x, (-1, 1)) -x*Heaviside(1 - x)/2 - Heaviside(x - 1)/(2*x) >>> inverse_mellin_transform(f, s, x, (1, oo)) (1/2 - x**2/2)*Heaviside(1 - x)/x See Also ======== mellin_transform hankel_transform, inverse_hankel_transform rrZr)rZr)rrlrkrSrms rFinverse_mellin_transformrqis*j "!8U1X > C C Le LLrHc[X0-[U[R-U-U-5-U[R[R 45nUR [5(d[Xv5[R4$[X[R[R 45nU[R[R [R4;dUR [5(a [XPS5eUR(d [XPS5eURSupyUR [5(a [XPS5e[Xv5U 4$)z Compute a general Fourier-type transform .. math:: F(k) = a \int_{-\infty}^{\infty} e^{bixk} f(x)\, dx. For suitable choice of *a* and *b*, this reduces to the standard Fourier and inverse Fourier transforms. z$function not integrable on real axisrrr)r,rrrmrrr~r-rrNaNr;rrU) rjrkrErrrwrr integral_frys rF_fourier_transformrus !#c!AOO+A-a/001a6H6H!**2UVA 55??%qvv--1!"4"4ajjABJa((!**aee<< x@X@X$T.TUU >>$T.JKKffQiGAuuX$T.KLL Q !4 ''rHc0\rSrSrSrSrSrSrSrSr g) FourierTypeTransformiz"Base class for Fourier transforms.c2[SUR-5eNz,Class %s must implement a(self) but does notrhrErVs rFrFourierTypeTransform.a! :T^^ KM MrHc2[SUR-5eNz,Class %s must implement b(self) but does notrzrVs rFrFourierTypeTransform.br|rHc [XUUR5UR5URR40UD6$rf)rurrrErrBrjrkrErms rFrn'FourierTypeTransform._compute_transforms<!!"&&&(DFFH"&.."6"6A:?A ArHcUR5nUR5n[XA-[U[R -U-U-5-U[R [R45$rf)rrr-rrrmrr)rBrjrkrErrs rFrs!FourierTypeTransform._as_integralsX FFH FFHC!// 1! 3A 566A>> from sympy import fourier_transform, exp >>> from sympy.abc import x, k >>> fourier_transform(exp(-x**2), x, k) sqrt(pi)*exp(-pi**2*k**2) >>> fourier_transform(exp(-x**2), x, k, noconds=False) (sqrt(pi)*exp(-pi**2*k**2), True) See Also ======== inverse_fourier_transform sine_transform, inverse_sine_transform cosine_transform, inverse_cosine_transform hankel_transform, inverse_hankel_transform mellin_transform, laplace_transform r)rrrjrkrErms rFfourier_transformrs N A! $ ) ) 2E 22rHc(\rSrSrSrSrSrSrSrg)InverseFourierTransformiz Class representing unevaluated inverse Fourier transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse Fourier transforms, see the :func:`inverse_fourier_transform` docstring. zInverse FouriercgrrrVs rFrInverseFourierTransform.a#rrHc(S[R-$rkrrVs rFrInverseFourierTransform.b&sv rHrNrrrHrFrrs ErHrc :[XU5R"S0UD6$)aF Compute the unitary, ordinary-frequency inverse Fourier transform of `F`, defined as .. math:: f(x) = \int_{-\infty}^\infty F(k) e^{2\pi i x k} \mathrm{d} k. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`InverseFourierTransform` object. For other Fourier transform conventions, see the function :func:`sympy.integrals.transforms._fourier_transform`. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import inverse_fourier_transform, exp, sqrt, pi >>> from sympy.abc import x, k >>> inverse_fourier_transform(sqrt(pi)*exp(-(pi*k)**2), k, x) exp(-x**2) >>> inverse_fourier_transform(sqrt(pi)*exp(-(pi*k)**2), k, x, noconds=False) (exp(-x**2), True) See Also ======== fourier_transform sine_transform, inverse_sine_transform cosine_transform, inverse_cosine_transform hankel_transform, inverse_hankel_transform mellin_transform, laplace_transform r)rrrrErkrms rFinverse_fourier_transformr*s N #1 + 0 0 95 99rHc[X0-U"XA-U-5-U[R[R45nUR [ 5(d[ X5[R4$UR(d [X`S5eURSupUR [ 5(a [X`S5e[ X5U 4$)z Compute a general sine or cosine-type transform F(k) = a int_0^oo b*sin(x*k) f(x) dx. F(k) = a int_0^oo b*cos(x*k) f(x) dx. For suitable choice of a and b, this reduces to the standard sine/cosine and inverse sine/cosine transforms. rrr) r,rrrr~r-rrrr;rU) rjrkrErrKrwrrrys rF_sine_cosine_transformrXs !#aAh,AFFAJJ 78A 55??%qvv-- >>$T.JKKffQiGAuuX$T.KLL Q !4 ''rHc0\rSrSrSrSrSrSrSrSr g) SineCosineTypeTransformiqz? Base class for sine and cosine transforms. Specify cls._kern. c2[SUR-5eryrzrVs rFrSineCosineTypeTransform.awr|rHc2[SUR-5er~rzrVs rFrSineCosineTypeTransform.b{r|rHc [XUUR5UR5URRURR 40UD6$rf)rrrrE_kernrrs rFrn*SineCosineTypeTransform._compute_transformsL%aA&*ffh&*nn&:&:&*nn&:&:E?DE ErHcUR5nUR5nURRn[ XA-U"XR-U-5-U[ R [ R45$rf)rrrErr-rrr)rBrjrkrErrrs rFrs$SineCosineTypeTransform._as_integralsS FFH FFH NN Aac!eH q!&&!**&=>>rHrNrrrHrFrrqs MM E ?rHrc,\rSrSrSrSr\rSrSr Sr g) SineTransformiz Class representing unevaluated sine transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute sine transforms, see the :func:`sine_transform` docstring. Sinec8[S5[[5- $rkr"rrVs rFrSineTransform.aAwtBxrHc"[R$rfrrrVs rFrSineTransform.b uu rHrN rIrJrKrLrMrr&rrrrNrrHrFrrs E E rHrc :[XU5R"S0UD6$)a Compute the unitary, ordinary-frequency sine transform of `f`, defined as .. math:: F(k) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty f(x) \sin(2\pi x k) \mathrm{d} x. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`SineTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import sine_transform, exp >>> from sympy.abc import x, k, a >>> sine_transform(x*exp(-a*x**2), x, k) sqrt(2)*k*exp(-k**2/(4*a))/(4*a**(3/2)) >>> sine_transform(x**(-a), x, k) 2**(1/2 - a)*k**(a - 1)*gamma(1 - a/2)/gamma(a/2 + 1/2) See Also ======== fourier_transform, inverse_fourier_transform inverse_sine_transform cosine_transform, inverse_cosine_transform hankel_transform, inverse_hankel_transform mellin_transform, laplace_transform r)rrrs rFsine_transformrs H q ! & & / //rHc,\rSrSrSrSr\rSrSr Sr g)InverseSineTransformiz Class representing unevaluated inverse sine transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse sine transforms, see the :func:`inverse_sine_transform` docstring. z Inverse Sinec8[S5[[5- $rkrrVs rFrInverseSineTransform.arrHc"[R$rfrrVs rFrInverseSineTransform.brrHrNrrrHrFrrs E E rHrc :[XU5R"S0UD6$)a Compute the unitary, ordinary-frequency inverse sine transform of `F`, defined as .. math:: f(x) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty F(k) \sin(2\pi x k) \mathrm{d} k. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`InverseSineTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import inverse_sine_transform, exp, sqrt, gamma >>> from sympy.abc import x, k, a >>> inverse_sine_transform(2**((1-2*a)/2)*k**(a - 1)* ... gamma(-a/2 + 1)/gamma((a+1)/2), k, x) x**(-a) >>> inverse_sine_transform(sqrt(2)*k*exp(-k**2/(4*a))/(4*sqrt(a)**3), k, x) x*exp(-a*x**2) See Also ======== fourier_transform, inverse_fourier_transform sine_transform cosine_transform, inverse_cosine_transform hankel_transform, inverse_hankel_transform mellin_transform, laplace_transform r)rrrs rFinverse_sine_transformrs J a ( - - 6 66rHc,\rSrSrSrSr\rSrSr Sr g)CosineTransformiz Class representing unevaluated cosine transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute cosine transforms, see the :func:`cosine_transform` docstring. Cosinec8[S5[[5- $rkrrVs rFrCosineTransform.arrHc"[R$rfrrVs rFrCosineTransform.brrHrN rIrJrKrLrMrr$rrrrNrrHrFrrs E E rHrc :[XU5R"S0UD6$)a Compute the unitary, ordinary-frequency cosine transform of `f`, defined as .. math:: F(k) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty f(x) \cos(2\pi x k) \mathrm{d} x. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`CosineTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import cosine_transform, exp, sqrt, cos >>> from sympy.abc import x, k, a >>> cosine_transform(exp(-a*x), x, k) sqrt(2)*a/(sqrt(pi)*(a**2 + k**2)) >>> cosine_transform(exp(-a*sqrt(x))*cos(a*sqrt(x)), x, k) a*exp(-a**2/(2*k))/(2*k**(3/2)) See Also ======== fourier_transform, inverse_fourier_transform, sine_transform, inverse_sine_transform inverse_cosine_transform hankel_transform, inverse_hankel_transform mellin_transform, laplace_transform r)rrrs rFcosine_transformrs H 1 # ( ( 15 11rHc,\rSrSrSrSr\rSrSr Sr g)InverseCosineTransformi?z Class representing unevaluated inverse cosine transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse cosine transforms, see the :func:`inverse_cosine_transform` docstring. zInverse Cosinec8[S5[[5- $rkrrVs rFrInverseCosineTransform.aLrrHc"[R$rfrrVs rFrInverseCosineTransform.bOrrHrNrrrHrFrr?s E E rHrc :[XU5R"S0UD6$)a Compute the unitary, ordinary-frequency inverse cosine transform of `F`, defined as .. math:: f(x) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty F(k) \cos(2\pi x k) \mathrm{d} k. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`InverseCosineTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import inverse_cosine_transform, sqrt, pi >>> from sympy.abc import x, k, a >>> inverse_cosine_transform(sqrt(2)*a/(sqrt(pi)*(a**2 + k**2)), k, x) exp(-a*x) >>> inverse_cosine_transform(1/sqrt(k), k, x) 1/sqrt(x) See Also ======== fourier_transform, inverse_fourier_transform, sine_transform, inverse_sine_transform cosine_transform hankel_transform, inverse_hankel_transform mellin_transform, laplace_transform r)rrrs rFinverse_cosine_transformrSs H "! * / / 8% 88rHc[U[X2U-5-U-U[R[R45nUR [ 5(d[Xe5[R4$UR(d [X@S5eURSupgUR [ 5(a [X@S5e[Xe5U4$)zj Compute a general Hankel transform .. math:: F_\nu(k) = \int_{0}^\infty f(r) J_\nu(k r) r \mathrm{d} r. rrr) r,r(rrrr~r-rrrr;rU)rjrrErQrwrrrys rF_hankel_transformr~s !GB!$$Q&AFFAJJ(?@A 55??%qvv-- >>$T.JKKffQiGAuuX$T.KLL Q !4 ''rHc:\rSrSrSrSrSrSr\S5r Sr g) HankelTypeTransformiz# Base class for Hankel transforms. c UR"URURURURS40UD6$NrK)rnrAr[r_rU)rBrms rFrHankelTypeTransform.doitsB&&t}}'+'='='+'>'>'+yy|0*/ 0 0rHc 2[XX4UR40UD6$rf)rr)rBrjrrErQrms rFrn&HankelTypeTransform._compute_transforms qdjjBEBBrHc|[U[XCU-5-U-U[R[R45$rf)r-r(rrr)rBrjrrErQs rFrs HankelTypeTransform._as_integrals1'"c**1,q!&&!**.EFFrHcURURURURURS5$r)rsrAr[r_rUrVs rFrHankelTypeTransform.as_integrals8  !%!7!7!%!8!8!%1/ /rHrN) rIrJrKrLrMrrnrsrrrNrrHrFrrs,0CG//rHrc\rSrSrSrSrSrg)HankelTransformiz Class representing unevaluated Hankel transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute Hankel transforms, see the :func:`hankel_transform` docstring. HankelrNrIrJrKrLrMrrNrrHrFrrs ErHrc :[XX#5R"S0UD6$)aY Compute the Hankel transform of `f`, defined as .. math:: F_\nu(k) = \int_{0}^\infty f(r) J_\nu(k r) r \mathrm{d} r. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`HankelTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import hankel_transform, inverse_hankel_transform >>> from sympy import exp >>> from sympy.abc import r, k, m, nu, a >>> ht = hankel_transform(1/r**m, r, k, nu) >>> ht 2*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/(2**m*gamma(m/2 + nu/2)) >>> inverse_hankel_transform(ht, k, r, nu) r**(-m) >>> ht = hankel_transform(exp(-a*r), r, k, 0) >>> ht a/(k**3*(a**2/k**2 + 1)**(3/2)) >>> inverse_hankel_transform(ht, k, r, 0) exp(-a*r) See Also ======== fourier_transform, inverse_fourier_transform sine_transform, inverse_sine_transform cosine_transform, inverse_cosine_transform inverse_hankel_transform mellin_transform, laplace_transform r)rr)rjrrErQrms rFhankel_transformrs \ 1 ' , , 5u 55rHc\rSrSrSrSrSrg)InverseHankelTransformiz Class representing unevaluated inverse Hankel transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse Hankel transforms, see the :func:`inverse_hankel_transform` docstring. zInverse HankelrNrrrHrFrrs ErHrc :[XX#5R"S0UD6$)a_ Compute the inverse Hankel transform of `F` defined as .. math:: f(r) = \int_{0}^\infty F_\nu(k) J_\nu(k r) k \mathrm{d} k. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`InverseHankelTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Note that for this transform, by default ``noconds=True``. Examples ======== >>> from sympy import hankel_transform, inverse_hankel_transform >>> from sympy import exp >>> from sympy.abc import r, k, m, nu, a >>> ht = hankel_transform(1/r**m, r, k, nu) >>> ht 2*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/(2**m*gamma(m/2 + nu/2)) >>> inverse_hankel_transform(ht, k, r, nu) r**(-m) >>> ht = hankel_transform(exp(-a*r), r, k, 0) >>> ht a/(k**3*(a**2/k**2 + 1)**(3/2)) >>> inverse_hankel_transform(ht, k, r, 0) exp(-a*r) See Also ======== fourier_transform, inverse_fourier_transform sine_transform, inverse_sine_transform cosine_transform, inverse_cosine_transform hankel_transform mellin_transform, laplace_transform r)rr)rrErrQrms rFinverse_hankel_transformrs \ "! . 3 3 rs#;;)/#4B==AHH7CC?GG2=91/,EE'.+.&!0!(Y Y x6 U 1 +>A; A;H'B)2X*BZ  h2V  48:8:t 1Z.1Zh5Mx 4((<],],+&'3T2&':\ 4((0?/?8+($0N2(%7P-($2N4($9V 4((*/+/4 ) .6b 0 .=l+*,,..!88 66"::$>>rH