+ j&Rt^RIHtHt^RIHt^RIHtHt^RI H t ^RI H t H t HtHtHt^RIHt^RIHtHt^RIHt^R IHt^R IHt^R IHtHt^R IH t H!t!H"t"^R I#H$t$H%t%^RI&H't'H(t(H)t)H*t*^RI+H,t,^RI-H.t.H/t/H0t0^RI1H2t2^RI3H4t4H5t5H6t6H7t7^RI8H9t9^RI:H;t;^RIH?t?^RI@HAtAHBtB^RICHDtD^RIEHFtFHGtGHHtHHItIHJtJ^RIKHLtL^RIMHNtNHOtO^RIPHQtQ^RIRHStS^RITHUtU!RR ]V4tW!R!R"]4tXR#tYR$tZ]Z!R%4t[R&t\][]\R'3R(l4t]!R)R*]X4t^R+t_R,t`!R-R.]a4tbR/tc]Z!R'4RVR0l4tdR1se!R2R3]X4tfR4tg]Z!R'4RWR5l4th!R6R7]X4ti!R8R9]i4tjR:tk!R;R<]i4tlR=tm]Z!R'4RWR>l4tn!R?R@]X4to!RARB]o4tpRCtq!RDRE]o4trRFts!RGRH]o4ttRItu!RJRK]o4tvRLtw]Z!R'4RWRMl4tx!RNRO]X4ty!RPRQ]y4tzRRt{!RSRT]y4t|RUt}^R1I~HuHt]EPt]EPt]EPt]EP t]EP t]EPtR1#)XzIntegral 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)debugc6aa]tRt^(toRtV3RltRtVtV;t#)IntegralTransformErrorav 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. cB<\SV`V: RV: R24W nR#)z" Transform could not be computed: .N)super__init__function)self transformr?msg __class__s&&&&[/home/luca/screen-checking/.venv/lib/python3.14/site-packages/sympy/integrals/transforms.pyr>IntegralTransformError.__init__6s 9BC H J )r?) __name__ __module__ __qualname____firstlineno____doc__r>__static_attributes____classdictcell__ __classcell__)rC __classdict__s@@rDr:r:(s !!rFr:ca]tRt^>> 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 (VP^,#)z The function to be transformed. argsr@s&rDr?IntegralTransform.functionSyy|rFc (VP^,#)z:The dependent variable of the function to be transformed. rSrUs&rDfunction_variable#IntegralTransform.function_variableXrWrFc (VP^,#)z$The independent transform variable. rSrUs&rDtransform_variable$IntegralTransform.transform_variable]rWrFc VPPPVP04VP0, #)zR This method returns the symbols that will exist when the transform is evaluated. )r? free_symbolsunionr\rYrUs&rDr_IntegralTransform.free_symbolsbs; }}))//1H1H0IJ%%&' 'rFc \hNNotImplementedErrorr@fxshintss&&&&,rD_compute_transform$IntegralTransform._compute_transformk!!rFc\hrcrdr@rgrhris&&&&rD _as_integralIntegralTransform._as_integralnrmrFch\V!pVR8Xd"\VPPRR4hV#)FN)r2r:rCname)r@extraconds&& rD_collapse_extra!IntegralTransform._collapse_extraqs0E{ 5=()<)2IntegralTransform._try_directly..ys+N+L4 $xx(>(>??+Ls(+TFz6[IT _try ] Caught IntegralTransformError, returns None) anyr?atomsrrkrYr\r:r8is_Addr )r@rjT try_directlyfnsf, rD _try_directlyIntegralTransform._try_directlyws 3N+/==+>+>|+LN333N+/==+>+>|+LNNN  ++DMM**D,C,CNGLN ]]yyyBBu * NO s3C%%D?Dc VPRR4pVPRR4pW1R&VP!R/VBwrEVeV#VP'EdUW!R&VPUu.uFEpVP!V.\ VPR,4,!P !R/VBNKG pp.p.p VFp\V\4'gV.pV PV^,4\V4^8XdVPV^,4K^\V4^8gKpWR,., pK VR8Xd\V !P4pM \V !pV'gV#VPV4p\V4'dV3\V4,#Wx3#V'd,\VPP VP"R4hVP%VP&4wrWP!\)V !.\ VPR,4,!,#uupi \dLi;i)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)``. needevalFsimplifyT:NN)poprrrTrClistdoit isinstancetupleappendlenrrrwr7r:_namer? as_coeff_mulrYr ) r@rjrrrrrhresruresscoeffrests &, rDrIntegralTransform.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$))B-5H&HJJJK%4*  s(A H924H>'H>> I  I cdVPVPVPVP4#rc)rpr?rYr\rUs&rD as_integralIntegralTransform.as_integrals,  0F0F!%!8!8: :rFcVP#rc)r)r@rTkwargss&*,rD_eval_rewrite_as_Integral+IntegralTransform._eval_rewrite_as_IntegralsrFrN)rGrHrIrJrKpropertyr?rYr\r_rkrprwrrrrrLrMrOs@rDrQrQ<s,''"" "EKN::  rFrQc`V'd&^RIHp^RIHpV!V!\ V4RR74#V#))r) powdenestT)polar)sympy.simplifyrsympy.simplify.powsimprr")exprrrrs&& rD _simplifyrs' +4 ."6dCDD KrFcaV3RlpV#)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:<a\S4RS/V3Rll4pV#)nocondsc:<S!V/VBpV'd V^,#V#rr)rrTrrr}s$*, rDwrapper0_noconds_..make_wrapper..wrappers#''C1v JrF)r)r}rdefaultsf rD make_wrapper_noconds_..make_wrappers' t 7    rFr)rrsf rD _noconds_rs$ rFFcV\W\P\P34#rc)r+rZeroInfinity)rgrhs&&rD_default_integratorrs QAFFAJJ/ 00rFTc$a \RRV4o V!VS ^, ,V,V4pVP\4'gL\VP S V4V4\ P \ P3\ P3#VP'g\RVR4hVP^,wrVVP\4'd\RVR4hV 3Rlp\V4Uu.uF q!V4NK p pV Uu.uFq^,R8wgKVNK p pV PRR 7V 'g\RVR 4hV ^,wrp \VP S V4V4W3V 3#uupiuupi) z/Backend function to compute Mellin transforms. rizmellin-transformMellincould not compute integralintegral in unexpected formc<^RIHp\Pp\Pp\P p\ \V44p\RRR7pVEFp\Pp\Pp .p \V4EFp V P\R4P\S4V4p V P'd@V PR9g/V PS4'gV PV4'g W., p KV!W4p V P'dV PR9d W., p KV P V8Xd\#V P$V 4p K\'V P V4pEK V\PJdW8wd\#W4pEKcV \PJdW8wd\'W4pEK\)V\+V !4pEK W#V3#)z> Turn ``cond`` into a strip (a, b), and auxiliary conditions. )_solve_inequalitytT)realc0VP4^,#r) as_real_imagrhs&rD:_mellin_transform..process_conds..)s!.."21"5rF)z==z!=)sympy.solvers.inequalitiesrrNegativeInfinityrtruer/r.rr0replacersubs is_Relationalrel_opr{ltsrgtsr r2r1)rvrabauxcondsrca_b_aux_dd_solnris& rD process_conds(_mellin_transform..process_condss| A   JJff&,' #D !AB##BDq\YY577;tBqE1~HH ,66!99BFF1IICKD(/))) |3CKD88q=TXXr*BTXXr*B!""#J1---"'J#r4y)56SyrFFcTV^,V^,, \V^,43#r)r rs&rDr#_mellin_transform..BsadQqTk9QqT?;rFkeyzno convergence found)r-r{r,rrrrrr is_Piecewiser:rTr0sort)rgrhs_ integratorrFrvrrrrrrris&&&&& @rD_mellin_transformrsQ s&*A1q1u:>1%A 55??21A4F4F 3SUVU[U[[[ >>>$Xq2NOOffQiGAuuX$ a68 8%N(1 7!]1 E 7 /11QQE / JJ;J< $Xq2HIIaIA# QVVAr]H -vs :: 8 /sFF ,F c:a]tRtRtoRtRtRtRtRtRt Vt R#) 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 \WV3/VB#rc)rrfs&&&&,rDrk"MellinTransform._compute_transformWs q2E22rFc\WV^, ,,V\P\P34#r)r,rrrros&&&&rDrpMellinTransform._as_integralZs(a!e* q!&&!**&=>>rFc.p.p.pVF#wwrVpW%., pW6., pWG., pK% \V!\V!3\V!3pV^,^,V^,^,8R8XgV^,R8Xd\RRR4hV#)rTFrNzno combined convergence.)rr r2r:) r@rurrrvsasbrrs && rDrwMellinTransform._collapse_extra]s   KHRa IA IA CKD!AwQ #t*, F1IQ "t +s1v($ :< < rFrN) rGrHrIrJrKrrkrprwrLrMrs@rDrrKs% E3?  rFrc :\WV4P!R/VB#)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)rgrhrirjs&&&,rDmellin_transformrls R 1 # ( ( 15 11rFcpVwrE\V\, 4p\V\, 4p\V)V,VP4^,, 4p\ WA,V,V,4\ ^V, V, WA,, 4RV,\,3#)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) )r rrrr))m_nrirrmnrs&&&& rD _rewrite_sinrsJ DA1R4A1R4A1q~~'**+A q1 uQUQY_5Qwrz AArFc]tRtRtRtRtR#)MellinTransformStripErroriz> Exception raised by _rewrite_gamma. Mainly for internal use. rN)rGrHrIrJrKrLrrFrDrrs  rFrc aaa/a0a1a2\W#.4wo/o0V/V03Rlp.pSP\4FwpVPS4'gKVP^,pVP 'dVP !S4^,pVP!S4wrWX., pKy SP\\\\4FpVPS4'gKVP^,pVP 'dVP !S4^,pVP!S4wrWX\, ., pK VU u.uF!qP'd \V 4MT NK# pp \Pp VFp V P 'dKT p M VU u.uF qV , NK pp \";QJdRV4F 'dK RM RM !RV44'dV P'g\%RRR4hT \'\(VU u.uFp \V P*4NK up \P4, p W8XdN\-V4^8XdT p M:T \'\.VU u.uFp \V P04NK up 4,p SP3SSV , 4o\PV , p \PV , pS/e S/V ,o/S0e S0V ,o0SP54wpp\6P8!V4p\6P8!V4p\;\=V\?R444\;\=V\?R444,p.p.p.p.p.pV3Rlo1V'Ed=VPA4wo2pV'dTTppTpMTTppTpV1V2V3R lpS2PS4'g VS2., pK\S2PB'g\ES2\F4'dS2PB'dS2PHpS2PFpM\K^4pS2PFpVPL'd0TpV^8dV'*pVVV3.\V4,, pEKVPS4'gAV!V4wr#V'g ^V, pVVV,., pVVV,., pEK^S1!S24hS2POS4'Edf\QS2S4pVPS4^8wdVPU4^,p\WVS4p \-V 4VPS48wd\XPZ!V4p VV., pTV U!u.uFp!SV!, V3NK up!, pEK%VP]4wpp!VV., pV!V),p!V!V!V4'dAV\PV!)^,3., pV\PV!)3., pEKVR., pV\P^V!^,3., pV\P^V!3., pEK\ES2\4'dwV!S2P^,4wr#V'dFV^8dV!V)V, V4R8XgV^8d"V!V)V, V4R8Xd \aR 4hVW#3., pEKo\ES2\4'dS2P^,pV'd;\V\, 4\^V\, , 4\p$p#p"M\cV!V4SS/S04wp"p#p$VV"V'*3V#V'*3., pVV$., pEK\ES2\4'dSS2P^,pV\VRR 7V3\\^, V, RR 7V'*3., pEK\ES2\4'd@S2P^,pV\\^, V, RR 7V3., pEK\ES2\4'dSS2P^,pV\\^, V, RR 7V3\VRR 7V'*3., pEK=S1!S24hV \7V!\7V!, ,p ....3wp%p&p'p(VV%V'R3VV(V&R33EFwp)p*p+pV)'gKV)PA4wpp!VR8wEd?V^8wEd7\\V44pVV, p,V!V, p-VPL'g \eR 4h\gV4Fp.V)V,V-V.V, ,3., p)K V'd_V ^\,^V, ^, ,VV!\Ph, ,,,p VVV,., pM^V ^\,^V, ^, ,VV!\Ph, ,,,p VVV),., pEKcV^8XdV*Pk^V!, 4EKV+PkV!4EK \7V!pV%Pm\nR 7V&Pm\nR 7V'Pm\nR 7V(Pm\nR 7V%V&3V'V(3W~V 3#uup iuup iuup iuup iuup!i)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) cN<\\V44pSfS\PJdR#SfVS8#SfVS8*#VS8R8XdR#VS8*R8XdR#V'dR#SP'g%SP'gVP'dR#\ R4h)zE Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)r rrrr_r)ris_numerrrs&&rDleft_rewrite_gamma..left s 2a5M :" * :r6M :7N G  G   ???booo((EFFrFc38"TFqPxK R#5irc) is_Rational)r|rhs& rDr~!_rewrite_gamma..?s5}! }sFTGammaNzNonrational multiplierc,<\RSRV,4#)Inverse MellinzUnrecognised form '%s'.)r:)factrgs&rD exception!_rewrite_gamma..exceptionas%&6;TW[;[\\rFc<VP!S4'g S!S4h\VS4pVP4^8wd S!S4hVP4#)z6Test if arg is of form a*s+b, raise exception if not. ) is_polynomialr5degree all_coeffs)rpr r ris& rD linear_arg"_rewrite_gamma..linear_arglsL$$Q''o%S! AxxzQo%<<> !rFz Gammas partially over the strip.)evaluateza is not an integerrr)8rrr)r{rTras_independentrr%r#r&r$ris_extended_realrOnerallr:rrqrrrras_numer_denomr make_argsrziprris_Powrrbaser is_Integerr r5rLTr3r6 all_rootsr NegativeOnerer TypeErrorrangeHalfrrr)3rgrirrr s_multipliersgrr_rhcommon_coefficient s_multiplierfacexponentnumerdenomrTfacsdfacs numer_gammas denom_gammas exponentialsrugammaslgammasufacsrrexp_rvrrsrgamma1gamma2fac_anapbmbqgammasplusminusnewanewckrrr r s3ff&& @@@@rD_rewrite_gammarEs+ ~vYFBG4M WWU^uuQxx ffQi :::$$Q'*C##A& WWS#sC (uuQxx ffQi :::$$Q'*C##A&(# )CPP-Q111SVq8-MP }}}!"  4AA=a)))=MA C5}5CCC5}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/ !3:c5k !!CR^NBB+7R*F+7R*G*I%eXf::b8s'l;9m4m m 7mc \RRVRR7pVP\4p\V4\ V4\ V43EFpVP 'dVPUu.uFp\WqWSVRR7NK ppVU u.uF q^,NK p p VU u.uF q^,NK pp \V!p V'g \WP\4R7p V PWR4\V !3u#\WaV^,V^,4wrrp\!YYT,, 4pT'dTpM^RIHpT!T4pTP*'d\-TP4^8Xd\T\/T4, 4TP^,P^,,\\/T4T, 4TP^,P^,,,p\/\1TP244TP4\6,8.pT\\9\-TP:4\-TP<48g^\?TP@4^,84\/\1TP244TP4\6,8H4., p\9T!pTR8Xd\R TR 4hTT,PYR4T3u# \R VR 4huupiuup iuup i \dEKi;i \"dEK i;i \(d\R TR 4hi;i) zjA helper for the real inverse_mellin_transform function, this one here assumes x to be real and positive. rzinverse-mellin-transformT)positiveF)r)gens) hyperexpandrzCould not calculate integralzdoes not convergers)!r-rewriter)r4r r rrT_inverse_mellin_transformrrr(rr2rEr:r* ValueErrorrrIrerrrrargumentdeltarr1r<r>rnu)rrix_strip as_meijergrhr&GrrrrrrCer*hrIrvs&&&&& rDrKrKs s.DAA %AQiAq 2 888VV%#.aAj6;=# %$((4aqTT4E("&'$QaDD$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)L!L&L+>L0MM0 M?M MMM/Ncja]tRtRtoRtRt]!R4t]!R4tRt ] R4t Rt R t R tVtR #) 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. rNonerc Vf\PpVf\Pp\P!WW#WE3/VB#rc)rX_none_sentinelrQ__new__)clsrrirhrroptss&&&&&&,rDr\InverseMellinTransform.__new__Cs< 9&55A 9&55A ((qDtDDrFcVP^,VP^,r!V\PJdRpV\PJdRpW3#)N)rTrXr[)r@rrs& rDfundamental_strip(InverseMellinTransform.fundamental_stripJsHyy|TYYq\1 &55 5A &55 5At rFc VPRR4\f?\\\\ \ \\\\\\\0 s\V4FYpVP'gKVP!V4'gK0VP"\9gKG\%RVRV,4h VP&p\)WW63/VB#)rTrzComponent %s not recognised.)r_allowedrr)r%r#r&r$rrrrrrr is_Functionr{r}r:rbrK)r@rrirhrjrgrQs&&&&, rDrk)InverseMellinTransform._compute_transformSs  *d#  UCc3dD$2H%Q'A}}}qaffH.D,-=q%Ca%GII(&&(qA5AArFcpVPPp\WV),,W$\P\P ,, V\P\P ,,34^\P ,\P,, #)rC_cr,r ImaginaryUnitrPi)r@rrirhrs&&&& rDrp#InverseMellinTransform._as_integralcsv NN  qb' A1??1::+E'Eq$%OOAJJ$>H?$@ABCADD&BXZ ZrFrN)rGrHrIrJrKrrr[rkr\rrbrkrprLrMrs@rDrXrX5sO E6]N sBEB ZZrFrXc X\WW#^,V^,4P!R/VB#)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 r)rXr)rrirhrQrjs&&&&,rDinverse_mellin_transformrpis*j "!8U1X > C C Le LLrFc\W0,\V\P,V,V,4,V\P\P 34pVP \4'g\Wv4\P3#\W\P\P 34pV\P\P \P39gVP \4'd \WPR4hVP'g \WPR4hVP^,wryVP \4'd \WPR4h\Wv4V 3#)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 axisrr)r+rrrlrrr{r,rrNaNr:rrT) rgrhrDrrrtrr integral_frvs &&&&&&& rD_fourier_transformrts !#c!AOO+A-a/001a6H6H!**2UVA 55??%qvv--1!"4"4ajjABJa((!**aee<< x@X@X$T.TUU >>>$T.JKKffQiGAuuX$T.KLL Q !4 ''rFc<a]tRtRtoRtRtRtRtRtRt Vt R#) FourierTypeTransformiz"Base class for Fourier transforms.c:\RVP,4hz,Class %s must implement a(self) but does notrerCrUs&rDrFourierTypeTransform.a! :T^^ KM MrFc:\RVP,4hz,Class %s must implement b(self) but does notryrUs&rDrFourierTypeTransform.br{rFc \WVVP4VP4VPP3/VB#rc)rtrrrCrr@rgrhrDrjs&&&&,rDrk'FourierTypeTransform._compute_transforms<!!"&&&(DFFH"&.."6"6A:?A ArFc VP4pVP4p\WA,\V\P ,V,V,4,V\P \P34#rc)rrr,rrrlrr)r@rgrhrDrrs&&&& rDrp!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)rrrgrhrDrjs&&&,rDfourier_transformrs N A! $ ) ) 2E 22rFc4a]tRtRtoRtRtRtRtRtVt R#)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 Fourierc^#rrrUs&rDrInverseFourierTransform.a#rrFc0^\P,#rirrUs&rDrInverseFourierTransform.b&sv rFrNrrs@rDrrs  ErFrc :\WV4P!R/VB#)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)rrrrDrhrjs&&&,rDinverse_fourier_transformr*s N #1 + 0 0 95 99rFc\W0,V!WA,V,4,V\P\P34pVP \ 4'g\ W4\P3#VP'g \W`R4hVP^,wrVP \ 4'd \W`R4h\ W4V 3#)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. rr) r+rrrr{r,rrrr:rT) rgrhrDrrKrtrrrvs &&&&&&&& rD_sine_cosine_transformrXs !#aAh,AFFAJJ 78A 55??%qvv-- >>>$T.JKKffQiGAuuX$T.KLL Q !4 ''rFc<a]tRtRtoRtRtRtRtRtRt Vt R#) SineCosineTypeTransformiqz? Base class for sine and cosine transforms. Specify cls._kern. c:\RVP,4hrxryrUs&rDrSineCosineTypeTransform.awr{rFc:\RVP,4hr}ryrUs&rDrSineCosineTypeTransform.b{r{rFc \WVVP4VP4VPPVPP 3/VB#rc)rrrrC_kernrrs&&&&,rDrk*SineCosineTypeTransform._compute_transformsL%aA&*ffh&*nn&:&:&*nn&:&:E?DE ErFcVP4pVP4pVPPp\ WA,V!WR,V,4,V\ P \ P34#rc)rrrCrr,rrr)r@rgrhrDrrrs&&&& rDrp$SineCosineTypeTransform._as_integralsS FFH FFH NN Aac!eH q!&&!**&=>>rFrNrrs@rDrrqs& MM E ??rFrc8a]tRtRtoRtRt]tRtRt Rt Vt R#) 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. Sinec@\^4\\4, #rir!rrUs&rDrSineTransform.aAwtBxrFc"\P#rcrrrUs&rDrSineTransform.b uu rFrN rGrHrIrJrKrr%rrrrLrMrs@rDrrs% E E rFrc :\WV4P!R/VB#)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&&&,rDsine_transformrs H q ! & & / //rFc8a]tRtRtoRtRt]tRtRt Rt Vt R#)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 Sinec@\^4\\4, #rirrUs&rDrInverseSineTransform.arrFc"\P#rcrrUs&rDrInverseSineTransform.brrFrNrrs@rDrrs% E E rFrc :\WV4P!R/VB#)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&&&,rDinverse_sine_transformrs J a ( - - 6 66rFc8a]tRtRtoRtRt]tRtRt Rt Vt R#)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. Cosinec@\^4\\4, #rirrUs&rDrCosineTransform.arrFc"\P#rcrrUs&rDrCosineTransform.brrFrN rGrHrIrJrKrr#rrrrLrMrs@rDrrs% E E rFrc :\WV4P!R/VB#)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&&&,rDcosine_transformrs H 1 # ( ( 15 11rFc8a]tRtRtoRtRt]tRtRt Rt Vt R#)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 Cosinec@\^4\\4, #rirrUs&rDrInverseCosineTransform.aLrrFc"\P#rcrrUs&rDrInverseCosineTransform.bOrrFrNrrs@rDrr?s% E E rFrc :\WV4P!R/VB#)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&&&,rDinverse_cosine_transformrSs H "! * / / 8% 88rFc\V\W2V,4,V,V\P\P34pVP \ 4'g\We4\P3#VP'g \W@R4hVP^,wrgVP \ 4'd \W@R4h\We4V3#)zj Compute a general Hankel transform .. math:: F_\nu(k) = \int_{0}^\infty f(r) J_\nu(k r) r \mathrm{d} r. rr) r+r'rrrr{r,rrrr:rT)rgrrDrOrtrrrvs&&&&&& rD_hankel_transformr~s !GB!$$Q&AFFAJJ(?@A 55??%qvv-- >>>$T.JKKffQiGAuuX$T.KLL Q !4 ''rFcFa]tRtRtoRtRtRtRt]R4t Rt Vt R#) HankelTypeTransformiz# Base class for Hankel transforms. c VP!VPVPVPVP^,3/VB#ra)rkr?rYr\rT)r@rjs&,rDrHankelTypeTransform.doitsB&&t}}'+'='='+'>'>'+yy|0*/ 0 0rFc 2\WW4VP3/VB#rc)rr)r@rgrrDrOrjs&&&&&,rDrk&HankelTypeTransform._compute_transforms qdjjBEBBrFc\V\WCV,4,V,V\P\P34#rc)r,r'rrr)r@rgrrDrOs&&&&&rDrp HankelTypeTransform._as_integrals1'"c**1,q!&&!**.EFFrFcVPVPVPVPVP^,4#r)rpr?rYr\rTrUs&rDrHankelTypeTransform.as_integrals8  !%!7!7!%!8!8!%1/ /rFrN) rGrHrIrJrKrrkrprrrLrMrs@rDrrs/0CG//rFrc]tRtRtRtRtRtR#)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. HankelrNrGrHrIrJrKrrLrrFrDrrs ErFrc :\WW#4P!R/VB#)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)rgrrDrOrjs&&&&,rDhankel_transformrs \ 1 ' , , 5u 55rFc]tRtRtRtRtRtR#)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 HankelrNrrrFrDrrs ErFrc :\WW#4P!R/VB#)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)rrDrrOrjs&&&&,rDinverse_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"::$>>rF