g$4dZddlmZmZddlmZddlmZmZddl m Z ddl m Z m Z mZmZmZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZmZdd lm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDddlEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNmOZOddlPmQZQddlRmSZSddlTmUZUGd d!eVZWGd"d#eZXd$ZYd%ZZeZd&Z[d'Z\e[e\d(fd)Z]Gd*d+eXZ^d,Z_d-Z`Gd.d/eaZbd0ZceZd(dWd1Zdd2aeGd3d4eXZfd5ZgeZd(dXd6ZhGd7d8eXZiGd9d:eiZjd;ZkGd<d=eiZld>ZmeZd(dXd?ZnGd@dAeXZoGdBdCeoZpdDZqGdEdFeoZrdGZsGdHdIeoZtdJZuGdKdLeoZvdMZweZd(dXdNZxGdOdPeXZyGdQdReyZzdSZ{GdTdUeyZ|dVZ}dd2l~mcmZejZejZejZejZejZejZd2S)Yz Integral 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"eZdZdZfdZxZS)IntegralTransformErrora 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. cdt|d|d||_dS)Nz" Transform could not be computed: .)super__init__function)self transformr@msg __class__s V/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/integrals/transforms.pyr?zIntegralTransformError.__init__6s= 9BCCC H J J J  )__name__ __module__ __qualname____doc__r? __classcell__)rDs@rEr;r;(sB  !!!!!!!!!rFr;ceZdZdZedZedZedZedZdZ dZ dZ d Z d Z ed Zd Zd S)IntegralTransforma} 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|jdS)z! The function to be transformed. rargsrAs rEr@zIntegralTransform.functionSy|rFc|jdS)z; The dependent variable of the function to be transformed. rOrQs rEfunction_variablez#IntegralTransform.function_variableXrRrFc|jdS)z% The independent transform variable. rOrQs rEtransform_variablez$IntegralTransform.transform_variable]rRrFc^|jj|jh|jhz S)zj This method returns the symbols that will exist when the transform is evaluated. )r@ free_symbolsunionrXrUrQs rErZzIntegralTransform.free_symbolsbs3 })//1H0IJJ%&' 'rFc tNNotImplementedErrorrAfxshintss rE_compute_transformz$IntegralTransform._compute_transformk!!rFctr]r^rArarbrcs rE _as_integralzIntegralTransform._as_integralnrfrFcZt|}|dkrt|jjdd|S)NF)r3r;rDname)rAextraconds rE_collapse_extraz!IntegralTransform._collapse_extraqs0E{ 5==()z2IntegralTransform._try_directly..ysNNN#' $xx(>??NNNNNNrFz6[IT _try ] Caught IntegralTransformError, returns None) anyr@atomsr rerUrXr;r9is_Addr )rArdT try_directlyfns` rE _try_directlyzIntegralTransform._try_directlyws NNNN+/=+>+>|+L+LNNNNNN   +D+DM*D,CNNGLNN)   NOOO ]y BB1u sA A>=A>c dd}dd}|d<jd i\}}||S|jr |d<fd|jD}g}g}|D]} t | t s| g} || dt| dkr|| d dt| dkr|| d dgz }|dkrt| }n t|}|s|S |}t|r|ft |zS||fS#t$rYnwxYw|r tj jjd|j\} } | j t%| gt'jd dzzS) 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)``. needevalFsimplifyTNc vg|]5}j|gtjddzjdi6S)rTN)rDlistrPdoit)rsrbrdrAs rE z*IntegralTransform.doit..s_%%%E>4>QC$ty}*=*=$=?DMMuMM%%%rFrrWrTr)popr|rxrP isinstancetupleappendlenrrror8r;rD_namer@ as_coeff_mulrUrr) rArdr~rr{ryresrmressrbcoeffrests `` rErzIntegralTransform.doitsE*99Z//99Z..$j""++U++A =H 9  (E* %%%%%G%%%CED % %!!U++A AaD!!!q66Q;;LL1&&&&VVaZZaeW$E~~4j))++4j   ,,U33E??(6E%LL00<')      A($dmZAA A ood&<== t^T^sDzlT$)ABB-5H5H&HJJJs%6E E E-,E-cN||j|j|jSr])rir@rUrXrQs rE as_integralzIntegralTransform.as_integrals)  0F!%!8:: :rFc|jSr])r)rArPkwargss rE_eval_rewrite_as_Integralz+IntegralTransform._eval_rewrite_as_Integrals rFN)rGrHrIrJpropertyr@rUrXrZreriror|rrrrrFrErMrM<s,XXX''X'"""""" "EKEKEKN::X:     rFrMch|r/ddlm}ddlm}||t |dS|S)Nr)r) powdenestT)polar)sympy.simplifyrsympy.simplify.powsimprr#)exprrrrs rE _simplifyrs[ E++++++444444x ."6"6dCCCDDD KrFcfd}|S)aV 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). cDtdfd }|S)Nnocondsc,|i|}|r|dS|SNrr)rrPrrrts rEwrapperz0_noconds_..make_wrapper..wrappers-$'''C 1v JrF)r)rtrdefaults` rE make_wrapperz_noconds_..make_wrappersA t#*         rFr)rrs` rE _noconds_rs$$ rFFcPt||tjtjfSr])r,rZeroInfinity)rarbs rE_default_integratorrs QAFAJ/ 0 00rFTc tdd| || dz z|z|}|tsGt| ||t jt jft jfS|j std|d|j d\}}|trtd|d fd fd t|D}d |D}| d |std|d |d\}} } t| |||| f| fS)z0 Backend function to compute Mellin transforms. rczmellin-transformrTMellincould not compute integralrintegral in unexpected formcddlm}tj}tj}tj}t t|}tdd}|D]i}tj}tj} g} t|D]} | td t|} | j r3| jdvs*| s| |s| | gz } || |} | j r | jdvr| | gz } | j|krt#| j| } t'| j|}|tjur||krt#||},| tjur| |krt'| |}Rt)|t+| }k|||fS)zN Turn ``cond`` into a strip (a, b), and auxiliary conditions. r)_solve_inequalitytT)realc6|dSr) as_real_imagrbs rEz:_mellin_transform..process_conds..)s!.."2"21"5rF)z==z!=)sympy.solvers.inequalitiesrrNegativeInfinityrtruer0r/rr1replacersubs is_Relationalrel_oprrltsr gtsr!r3r2)rnrabauxcondsrca_b_aux_dd_solnrcs rE process_condsz(_mellin_transform..process_condss A@@@@@  Jf&,,'' #D ! ! ! * *AB#BDq\\ + +YY55777;tBqEE1~~H ,,66!99-,.FF1II-QCKD((Q//) |33QCKD8q==TXr**BBTXr**BB##aAJJ1---"''AJJ#r4y))!SyrFc&g|] }|Srr)rsrrs rErz%_mellin_transform..@s# 7 7 7!]]1   7 7 7rFc*g|]}|ddk|S)rWFrrsrbs rErz%_mellin_transform..As! / / /11QrFcN|d|dz t|dfS)NrrTrW)r rs rErz#_mellin_transform..Bs!adQqTk9QqT??;rFkeyzno convergence found)r.rrr-rrrrrr is_Piecewiser;rPr1sort) rarbs_ integratorrFrnrrrrrrcs @@rE_mellin_transformrs s&**A 1q1u:>1%%A 55??\211A4F 3SUVU[[[ >P$Xq2NOOOfQiGAtuuX8$ a688 8%%%%%N 8 7 7 7y 7 7 7E / / / / /E JJ;;J<<< J$Xq2HIIIaIAq# QVVAr]]H - -1vs ::rFc(eZdZdZdZdZdZdZdS)MellinTransformz 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 t|||fi|Sr])rr`s rErez"MellinTransform._compute_transformWs Aq22E222rFcbt|||dz zz|tjtjfSNrT)r-rrrrhs rErizMellinTransform._as_integralZs)!a!e* q!&!*&=>>>rFcg}g}g}|D]\\}}}||gz }||gz }||gz }t|t|ft|f}|dd|ddkdks |ddkrtddd|S)NrrTTFrzno combined convergence.)r r!r3r;) rArmrrrnsasbrrs rErozMellinTransform._collapse_extra]s     KHRa "IA "IA QCKDDAwQ #t*, F1IQ "t + +s1v($ :<< < rFN)rGrHrIrJrrerirorrFrErrKsR E333???     rFrc :t|||jdi|S)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)rarbrcrds rEmellin_transformrls*R )?1a # # ( 1 15 1 11rFcB|\}}t|tz }t|tz }t| |z|dz }t ||z|z|zt d|z |z ||zz d|ztzfS)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) rrT)r rrrr*)m_nrcrrmnrs rE _rewrite_sinrsJ DAq1R4A1R4A1q~~''**++A 1q1  uQUQY1_55Qwrz AArFceZdZdZdS)MellinTransformStripErrorzF Exception raised by _rewrite_gamma. Mainly for internal use. N)rGrHrIrJrrFrErrs DrFrc 8-./012t||g\-.-.fd}g}tD][}|s|jd}|jr|jd}|j\}} ||gz }\ttttD]c}|s|jd}|jr|jd}|j\}} ||tz gz }dd|D}tj /|D] } | js| /n/fd|D}td|Dr/jst#ddd /t%t&d |Dtj z } | /kr8t)|dkr/} n"/t%t*d |Dz} | z tj | z } tj | z } --| z-..| z.\}}t1j|}t1j|}t5t7|t9d t5t7|t9d z}g}g}g}g}g}fd0|r[|\122r||}}|}n||}}|}01fd}1s|1gz }n1jst?1t@r1jr1j!}1j }ntEd}1j }|j#r$2}|dkr| }|||fgtI|zz }|s)||\}}2sd|z }|||zgz }|||zgz }n]011%r.tM1}|'dkr}|(d}tS|}t)||'krtUj+|}||gz }|2fd|Dz }|,\}}||gz }|| z}||2r+|tj | dzfgz }|tj | fgz }n=|dgz }|tj-|dzfgz }|tj-|fgz }nt?1trh|1jd\}}2rC|dkr|| |z 2d ks|dkr#|| |z 2d krt]d|||fgz }nt?1tr|1jd}2r9t|tz td|tz z t}"}!} nt_||-.\} }!}"|| 2 f|!2 fgz }||"gz }nt?1trC1jd}|t|d 2fttdz |z d 2 fgz }nt?1tr01jd}|ttdz |z d 2fgz }nct?1trC1jd}|ttdz |z d 2ft|d 2 fgz }n 01|[| t1|t1|z z} ggggf\}#}$}%}&||#|%d f||&|$d ffD]*\}'}(})2|'r|'\}}|dkr|dkrtIt|}||z }*||z }+|j#stadtc|D]},|'|*|+|,|z zfgz }'2r3| dtzd|z dz z||tj2z zzz} |||zgz }n3| dtzd|z dz z||tj2z zzz} ||| zgz }|dkr|(3d|z n|)3||',t1|}|#4tj|$4tj|%4tj|&4tj|#|$f|%|&f|| | fS)a 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) ctt|}tjurdS|kS|kS|kdkrdS|kdkrdS|rdSjsjs|jrdSt d)zU Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)r rrrrZr)ris_numerrrs rEleftz_rewrite_gamma..left s 2a55MM :" **4 :r6M :7N G  5 G  4  4 ? bo  4((EFFFrFrrTc>g|]}|jrt|n|Sr)is_extended_realrrs rErz"_rewrite_gamma..8s*PPPQq18SVVVqPPPrFcg|]}|z Srr)rsrbcommon_coefficients rErz"_rewrite_gamma..>sAAAaQ))AAArFc3$K|] }|jV dSr]) is_Rationalrs rEruz!_rewrite_gamma..?s$55! 555555rFGammaNzNonrational multiplierc6g|]}t|jSr)rqrs rErz"_rewrite_gamma..Bs64E4E4E1256acFF4E4E4ErFc6g|]}t|jSr)rprs rErz"_rewrite_gamma..Is ===!qvv===rFTFc,tdd|zS)NInverse MellinzUnrecognised form '%s'.)r;)factras rE exceptionz!_rewrite_gamma..exceptionas%&6;TW[;[\\\rFc|js t|}|dkr |S)z7 Test if arg is of form a*s+b, raise exception if not. rT) is_polynomialr6degree all_coeffs)rrrrrcs rE linear_argz"_rewrite_gamma..linear_argls`$3$Q'' &ioo%S! AxxzzQioo%<<>> !rFcg|] }|z f Srr)rsrrrcs rErz"_rewrite_gamma..s"777q!a%*777rFrz Gammas partially over the strip.)evaluaterWza is not an integerr)6rrwr*rrrPrxas_independentrr&r$r'r%rOnerallrr;rrrrras_numer_denomr make_argsrziprris_Powrrbaser is_Integerrrr6rLTr4r7 all_rootsr NegativeOner_r TypeErrorrangeHalfrrr)3rarcrrr s_multipliersgrr_rb s_multiplierfacexponentnumerdenomrPfacsdfacs numer_gammas denom_gammas exponentialsugammaslgammasufacsrr exp_rnrrsrgamma1gamma2fac_anapbmbqgammasplusminusnewanewckrrrrrrs3`` @@@@@@rE_rewrite_gammar3s ~1vYYFBGGGGGG4M WWU^^!!uuQxx  fQi : +$#$Q''*C#3#A&&q% WWS#sC ( ($$uuQxx  fQi : +$#$Q''*C#3#A&&q%(# PP-PPPM } !"  E BAAA=AAAM 55}555 5 5N  /N$Wd4LMMM%fT4E4E6C4E4E4EFGe'M'MML))) }   " "-LL-==}===>>?L q!L.!!A % Cu\!H ~ l ~ l##%%LE5 M% E M% E E6$<<(( ) )DUF5MM1J1J,K,K KD D ELLL]]]]] f"h  +\WGEE+\WGE " " " " " " "xx{{S " dVOEE [P "JtS11P "{ yx ||x &!88#8D$s4yy00XXa[[ &!z$''1"T6Dq ) q !ioo%    " ": "T1 AxxzzQq 1a[[r77ahhjj(( *1--B% 77777B7777<<>>DAq aSLE !GAtAx   0QUQBFO,,QUQBK=(" Q]AE233Q]A.// e $ $" ":dil++DAq <EEttQBqD(33u<<EEttQBqD(33t;;-:<<< Ax GG c " " "  ! A N',QrT{{E!ad(OOR'3JJqMM1b"'M'M$ f(l+f(l-CD DD dVOEE c " " " ! A c!e,,,h7"Q$(U333\BD DDD c " " " ! A c"Q$(U333X>? ?DD c " " " ! A c"Q$(U333X>!e,,,(l;= =DD)D// !M f"P3:c5k !!CR^NBB+7R*F+7R*G*I  %eX ::<.sE%%%.aAuj6;===%%%rFcg|] }|d S)rTrrsrs rErz-_inverse_mellin_transform..s(((aQqT(((rFcg|] }|d S)rrr<s rErz-_inverse_mellin_transform..s'''QAaD'''rF)gensrrT) hyperexpandrzCould not calculate integralFzdoes not convergerk) r.rewriter*r5r r rxrPrrwr)rr3r3r;r+ ValueErrorrr?r_rrrrargumentdeltarr2r*r,rnu)rrcx_r:r9rrrrrrCerr8hr?rnrbs ` `` @rEr7r7sz s.DAAAA %AQiiAq 2/)/) 8 0%%%%%%%V%%%D)(4(((E''$'''Dt*C =Ssyy';';<<<88Ar??CK/ / / / ,Q58U1XFFOAq!Q%    H  1a1f%%AA    H   >AA I666666KNN& I I I,$a)GIII I~ >#af++"2"2a#a&&j))!&).*;;A ++AF1IN1,==> C OO$$qwrz12 RAD SYY.RXX\0ABBQZ))QWRZ799: :4y 5==( !%8:: :#||Ar""D(((( !11b 9 99s0,$D DD"D:: EEE""E>NcjeZdZdZdZedZedZdZe dZ dZ dZ d S) InverseMellinTransformz 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 h| tj}| tj}tj||||||fi|Sr])rK_none_sentinelrM__new__)clsrrcrbrroptss rErOzInverseMellinTransform.__new__Cs? 9&5A 9&5A (aAq!DDtDDDrFc~|jd|jd}}|tjurd}|tjurd}||fS)Nr@)rPrKrN)rArrs rEfundamental_stripz(InverseMellinTransform.fundamental_stripJsHy|TYq\1 &5 5 5A &5 5 5A!t rFc |ddtJtttt t ttttttth at|D]@}|jr7||r"|jtvrt%d|d|zA|j}t)||||fi|S)NrTrzComponent %s not recognised.)r_allowedrr*r&r$r'r%rrrrrrr is_Functionrrrtr;rTr7)rArrcrbrdrar:s rErez)InverseMellinTransform._compute_transformSs  *d###  UCc3dD$2H%Q'' I IA} Iq IafH.D.D,-=q%Ca%GIII&(Aq%AA5AAArFc|jj}t||| zz||tjtjzz |tjtjzzfdtjztjzz SNrW)rD_cr-r ImaginaryUnitrPi)rArrcrbrs rEriz#InverseMellinTransform._as_integralcso N !qb' Aq1?1:+E'Eq$%OAJ$>H?$@AABCAD&BXZ ZrFN) rGrHrIrJrrrNrZrOrrTrerirrFrErKrK5s EU6]]N sBEEEXBBB ZZZZZrFrKc Vt||||d|djdi|S)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 rrTr)rKr)rrcrbr:rds rEinverse_mellin_transformr^is8j D !!Q58U1X > > C L Le L LLrFct||zt|tjz|z|zz|tjtjf}|tst||tj fSt||tjtjf}|tjtjtj fvs|trt||d|j st||d|j d\}} |trt||dt||| fS)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,rrr[rrrrr-rrNaNr;rrP) rarbr2rrrlrr integral_frns rE_fourier_transformrbs* !A#c!AO+A-a/0001a6H!*2UVVA 55??.H%%qv--1q!"4ajABBJa(!*ae<<< x@X@X<$T1.TUUU >L$T1.JKKKfQiGAtuuXM$T1.KLLL Q ! !4 ''rFc*eZdZdZdZdZdZdZdS)FourierTypeTransformz# Base class for Fourier transforms.c0td|jzNz,Class %s must implement a(self) but does notr_rDrQs rErzFourierTypeTransform.a!! :T^ KMM MrFc0td|jzNz,Class %s must implement b(self) but does notrgrQs rErzFourierTypeTransform.brhrFc t||||||jjfi|Sr])rbrrrDrrArarbr2rds rErez'FourierTypeTransform._compute_transformsI!!Q"&&&((DFFHH"&."6AA:?AA ArFc|}|}t||zt|tjz|z|zz|tjtjfSr])rrr-rrr[rr)rArarbr2rrs rEriz!FourierTypeTransform._as_integrals\ FFHH FFHH!C!/ 1! 3A 5666A>> 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)rprrarbr2rds rEfourier_transformrzs+N * Aq! $ $ ) 2 2E 2 22rFc"eZdZdZdZdZdZdS)InverseFourierTransformz 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 FouriercdSrrrQs rErzInverseFourierTransform.a#rsrFc dtjzSrYrvrQs rErzInverseFourierTransform.b&s v rFNrwrrFrEr|r|sC ErFr|c :t|||jdi|S)a 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)r|rrr2rbrds rEinverse_fourier_transformr*s+N 1 "1a + + 0 9 95 9 99rFct||z|||z|zz|tjtjf}|t st ||tjfS|jst||d|j d\}} |t rt||dt ||| fS)a  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,rrrrrr-rrrr;rP) rarbr2rrKrlrrrns rE_sine_cosine_transformrXs !A#aa!Ahh,AFAJ 788A 55??.H%%qv-- >L$T1.JKKKfQiGAtuuXM$T1.KLLL Q ! !4 ''rFc*eZdZdZdZdZdZdZdS)SineCosineTypeTransformzK Base class for sine and cosine transforms. Specify cls._kern. c0td|jzrfrgrQs rErzSineCosineTypeTransform.awrhrFc0td|jzrjrgrQs rErzSineCosineTypeTransform.b{rhrFc t||||||jj|jjfi|Sr])rrrrD_kernrrls rErez*SineCosineTypeTransform._compute_transformsT%aA&*ffhh&*n&:&*n&:EE?DEE ErFc|}|}|jj}t ||z|||z|zz|t jt jfSr])rrrDrr-rrr)rArarbr2rrrs rEriz$SineCosineTypeTransform._as_integralsY FFHH FFHH N !AAac!eHH q!&!*&=>>>rFNrnrrFrErrqsc MMMMMM EEE ?????rFrc&eZdZdZdZeZdZdZdS) SineTransformz 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. SinecJtdttz SrYr"rrQs rErzSineTransform.aAwwtBxxrFctjSr]rrrQs rErzSineTransform.b u rFN rGrHrIrJrr&rrrrrFrErrsH E E   rFrc :t|||jdi|S)a1 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)rrrys rEsine_transformrs*H '=Aq ! ! & / / / //rFc&eZdZdZdZeZdZdZdS)InverseSineTransformz 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 SinecJtdttz SrYrrQs rErzInverseSineTransform.arrFctjSr]rrQs rErzInverseSineTransform.brrFNrrrFrErrsH E E   rFrc :t|||jdi|S)am 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 rEinverse_sine_transformrs+J . 1a ( ( - 6 6 6 66rFc&eZdZdZdZeZdZdZdS)CosineTransformz 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. CosinecJtdttz SrYrrQs rErzCosineTransform.arrFctjSr]rrQs rErzCosineTransform.brrFN rGrHrIrJrr$rrrrrFrErrsH E E   rFrc :t|||jdi|S)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)rrrys rEcosine_transformrs*H )?1a # # ( 1 15 1 11rFc&eZdZdZdZeZdZdZdS)InverseCosineTransformz 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 CosinecJtdttz SrYrrQs rErzInverseCosineTransform.aLrrFctjSr]rrQs rErzInverseCosineTransform.bOrrFNrrrFrErr?sH E E   rFrc :t|||jdi|S)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 rEinverse_cosine_transformrSs+H 0 !!Q * * / 8 8% 8 88rFct|t|||zz|z|tjtjf}|t st||tjfS|j st||d|j d\}}|t rt||dt|||fS)zv 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(rrrrrr-rrrr;rP)rarr2rErlrrrns rE_hankel_transformr~s !GB!$$$Q&AFAJ(?@@A 55??.H%%qv-- >L$T1.JKKKfQiGAtuuXM$T1.KLLL Q ! !4 ''rFc:eZdZdZdZdZdZedZdS)HankelTypeTransformz+ Base class for Hankel transforms. c X|j|j|j|j|jdfi|SNr@)rer@rUrXrP)rArds rErzHankelTypeTransform.doitsA&t&t}'+'='+'>'+y|00*/ 00 0rFc .t|||||jfi|Sr])rr)rArarr2rErds rErez&HankelTypeTransform._compute_transforms" Aq"djBBEBBBrFc~t|t|||zz|z|tjtjfSr])r-r(rrr)rArarr2rEs rEriz HankelTypeTransform._as_integrals5'"ac***1,q!&!*.EFFFrFcf||j|j|j|jdSr)rir@rUrXrPrQs rErzHankelTypeTransform.as_integrals3  !%!7!%!8!%1// /rFN) rGrHrIrJrrerirrrrFrErrsl000CCCGGG//X///rFrceZdZdZdZdS)HankelTransformz 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. HankelNrGrHrIrJrrrFrErrs EEErFrc <t||||jdi|S)a 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)rarr2rErds rEhankel_transformrs,\ -?1aB ' ' , 5 5u 5 55rFceZdZdZdZdS)InverseHankelTransformz 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 HankelNrrrFrErrs EEErFrc <t||||jdi|S)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)rr2rrErds rEinverse_hankel_transformrs-\ 4 !!Q2 . . 3 < rs########;;;;;;;;;;;;;;))))))))//////######444444BBBBBBBB==========AAAAAAAAHHHHHHHHHHHH777777CCCCCCCCCC??????GGGGGGGGGGGG222222======999999111111////////,,,,,,EEEEEEEEEEEEEE''''''........++++++......&&&&&&!!!!!0!!!(Y Y Y Y Y Y Y Y x6 9U  111 +>A;A;A; A;H'B)2)2)2X*B*B*BZ        h2h2h2V  48:8:8:8:t 1Z1Z1Z1Z1Z.1Z1Z1Zh5M5M5Mx 4((((<]]]]],]]],+&'3'3'3T2&':':':\ 4((((0?????/???8+($0$0$0N2(%7%7%7P-($2$2$2N4($9$9$9V 4((((*/////+///4     )   .6.6.6b     0   .=.=.=l+********,.!8 6":$>rF