a RG5dHe@s6dZddlmZmZddlmZddlmZmZm Z ddl m Z ddl m Z mZmZmZmZmZmZmZmZddlmZddlmZmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(dd l)m*Z*dd l+m,Z,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:m;Z;mm?Z?ddl@mAZAmBZBmCZCddlDmEZEmFZFddlGmHZHmIZImJZJmKZKmLZLddlMmNZNmOZOmPZPmQZQddlRmSZSmTZTddlUmVZVmWZWmXZXddlYmZZZm[Z[m\Z\ddl]m^Z^ddl_m`Z`maZaddlbmcZcddldmeZemfZfmgZgmhZhmiZiddljmkZkddllmmZmmnZnddlompZpdd lqmrZrmsZsdd!ltmuZudd"lvmwZwmxZxdd#lymzZzm{Z{m|Z|dd$l}m~Z~dd%lmZGd&d'd'eZGd(d)d)eZd*d+Zd,d-Zed.Zd/d0Zeed1fd2d3ZGd4d5d5eZd6d7Zd8d9ZGd:d;d;eZdd?Zd@aGdAdBdBeZdCdDZdEdFZdGdHZeddIdJZdKdLZdMdNZdOdPZddQdRZddSdTZddUdVZddWdXZddYdZZdd[d\ZGd]d^d^eZdd_d`Zed1ddadbZGdcddddeZddedfZdgdhZed1ddidjZGdkdldleZGdmdndneZdodpZGdqdrdreZdsdtZed1ddudvZGdwdxdxeZGdydzdzeZd{d|ZGd}d~d~eZddZGdddeZddZGdddeZddZed1dddZGdddeZGdddeZddZGdddeZddZd@S)z Integral Transforms )reducewraps)repeat)SpiI)Add) AppliedUndef count_ops Derivativeexpandexpand_complex expand_mulFunctionLambda WildFunction)Mul)igcdilcm) _canonicalGeGtLt UnequalityEq)default_sort_keyordered)DummysymbolsWild)postorder_traversal) factorialrf)reargAbs polar_liftperiodic_argument)explog exp_polar)coshcothsinhtanhasinh)ceiling)MaxMinsqrt) Piecewisepiecewise_fold)coscotsintanatan)besselibesseljbesselkbessely) DiracDelta Heaviside)erferfcEi)digammagamma lowergamma)meijerg) integrateIntegral)_dummy)to_cnf conjuncts disjunctsOrAnd) MatrixBase) _lin_eq2dictPolyNonlinearError)roots)factorPoly)together)CRootOfRootSum)sympy_deprecation_warningSymPyDeprecationWarningignore_warnings)iterable)debugcs eZdZdZfddZZS)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. cstd||f||_dS)Nz'%s Transform could not be computed: %s.)super__init__function)self transformramsg __class__V/var/www/html/django/DPS/env/lib/python3.9/site-packages/sympy/integrals/transforms.pyr`@s zIntegralTransformError.__init__)__name__ __module__ __qualname____doc__r` __classcell__rgrgrerhr^2s r^c@s|eZdZdZeddZeddZeddZedd Zd d Z d d Z ddZ ddZ ddZ eddZddZdS)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. cCs |jdS)z! The function to be transformed. rargsrbrgrgrhra]szIntegralTransform.functioncCs |jdS)z; The dependent variable of the function to be transformed. rorqrgrgrhfunction_variablebsz#IntegralTransform.function_variablecCs |jdS)z% The independent transform variable. rorqrgrgrhtransform_variablegsz$IntegralTransform.transform_variablecCs|jj|jh|jhS)zj This method returns the symbols that will exist when the transform is evaluated. )ra free_symbolsunionrursrqrgrgrhrvlszIntegralTransform.free_symbolscKstdSNNotImplementedErrorrbfxshintsrgrgrh_compute_transformusz$IntegralTransform._compute_transformcCstdSrxryrbr|r}r~rgrgrh _as_integralxszIntegralTransform._as_integralcCs$t|}|dkr t|jjdd|S)NF)rOr^rfname)rbextracondrgrgrh_collapse_extra{sz!IntegralTransform._collapse_extrac s|d}tfddjtD }|r`z jjjjfi|}Wnty^d}Yn0j}|jstt |}||fS)Nc3s|]}|jVqdSrx)hasrs.0funcrqrgrh sz2IntegralTransform._try_directly..) anyraatomsr rrsrur^is_Addr)rbrTZ try_directlyfnrgrqrh _try_directlys"     zIntegralTransform._try_directlyc  sdd}dd}|d<jfi\}}|dur@|S|jrB|d<fdd|jD}g}g}|D]\} t| ts| g} || dt| d kr|| d qrt| d krr|| d dg7}qr|dkrt| }nt|}|s|Sz6 |}t |r t|gt|WS||fWSWnt y@Yn0|rZt j jjd|j\} } | j t| gtjd dS) 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)``. needevalFsimplifyTNcs6g|].}j|gtjddjfiqS)rrN)rflistrpdoitrr}rrbrgrh sz*IntegralTransform.doit..rrtrr)poprrrp isinstancetupleappendlenrrrr\r^rf_namera as_coeff_mulrsrr) rbrrrrrresrressr}coeffrestrgrrhrsN         zIntegralTransform.doitcCs||j|j|jSrx)rrarsrurqrgrgrh as_integrals zIntegralTransform.as_integralcOs|jSrx)r)rbrpkwargsrgrgrh_eval_rewrite_as_Integralsz+IntegralTransform._eval_rewrite_as_IntegralN)rirjrkrlpropertyrarsrurvrrrrrrrrgrgrgrhrnFs"    G rncCs4|r0ddlm}ddlm}||t|ddS|S)Nrr) powdenestT)polar)sympy.simplifyrsympy.simplify.powsimprr5)exprrrrrgrgrh _simplifys   rcsfdd}|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). cstdfdd }|S)Nnocondscs|i|}|r|dS|SNrrg)rrprrrrgrhwrappersz0_noconds_..make_wrapper..wrapper)r)rrdefaultrrh make_wrappersz_noconds_..make_wrapperrg)rrrgrrh _noconds_s rFcCst||tjtjfSrx)rHrZeroInfinity)r|r}rgrgrh_default_integrator srTc stdd|||d||}|tsNt|||tjtjftjfS|j s`t d|d|j d\}}|trt d|dfdd fd d t |D}d d |D}|j d dd|st d|d|d\}} } t||||| f| fS)z0 Backend function to compute Mellin transforms. r~zmellin-transformrrMellincould not compute integralrintegral in unexpected formcsRddlm}tj}tj}tj}tt|}tddd}|D] }tj}tj} g} t |D]} | t dd t |} | j r| jdvs| s| |s| | g7} qX|| |} | j r| jdvr| | g7} qX| j|krt| j| } qXt| j|}qX|tjur||krt||}q:| tjur8| |kr8t| |}q:t|t| }q:|||fS) zN Turn ``cond`` into a strip (a, b), and auxiliary conditions. r_solve_inequalitytTrealcSs |dSr) as_real_imagr}rgrgrh3z:_mellin_transform..process_conds..z==z!=)sympy.solvers.inequalitiesrrNegativeInfinityrtruerLrKrrMreplacer#subs is_Relationalrel_oprltsr1gtsr2rOrN)rrabauxcondsrca_b_aux_dd_solnr~rgrh process_conds#sP           z(_mellin_transform..process_condscsg|] }|qSrgrgrrrrgrhrJrz%_mellin_transform..cSsg|]}|ddkr|qS)rtFrgrrgrgrhrKrcSs|d|dt|dfS)Nrrrrtr rrgrgrhrLrz#_mellin_transform..keyno convergence found)rJrrIrrrrrr is_Piecewiser^rprMsort) r|r}s_ integratorrFrrrrrrg)rr~rh_mellin_transforms&  "   ' rc@s,eZdZdZdZddZddZddZd S) 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. rcKst|||fi|Srx)rr{rgrgrhrasz"MellinTransform._compute_transformcCs t|||d|tjtjfSNrr)rIrrrrrgrgrhrdszMellinTransform._as_integralc Csg}g}g}|D]*\\}}}||g7}||g7}||g7}qt|t|ft|f}|dd|ddkdks||ddkrtddd|S)NrrrTFrzno combined convergence.)r1r2rOr^) rbrrrrsasbrrrgrgrhrgs   (zMellinTransform._collapse_extraN)rirjrkrlrrrrrgrgrgrhrUs  rcKst|||jfi|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 )rr)r|r}r~rrgrgrhmellin_transformvs)rcCsp|\}}t|t}t|t}t| ||d}t||||td||||d|tfS)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) rrr)rrr0rrE)Zm_nr~rrmnrrgrgrh _rewrite_sins %  rc@seZdZdZdS)MellinTransformStripErrorzF Exception raised by _rewrite_gamma. Mainly for internal use. N)rirjrkrlrgrgrgrhrsrc-st||g\fdd}g}tD]F}|s>> 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) cstt|}dur"tjur"dSdur2|kSdurB|kS|kdkrRdS|kdkrbdS|rjdSjs|js||jrdStddS)zU Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)r r#rrrvr)ris_numer)rrrgrhlefts    z_rewrite_gamma..leftrrrcSsg|]}|jrt|n|qSrg)is_extended_realr%rrgrgrhrBrz"_rewrite_gamma..csg|] }|qSrgrgr)common_coefficientrgrhrHrcss|] }|jVqdSrx) is_RationalrrgrgrhrIrz!_rewrite_gamma..GammaNzNonrational multipliercSsg|]}t|jqSrg)rqrrgrgrhrLscSsg|]}t|jqSrg)rprrgrgrhrSrTFcstdd|S)NInverse MellinzUnrecognised form '%s'.)r^)factr|rgrh exceptionksz!_rewrite_gamma..exceptioncs8|st|}|dkr0|S)z7 Test if arg is of form a*s+b, raise exception if not. rr) is_polynomialrUdegree all_coeffs)r$r)rrr~rgrh linear_argvs    z"_rewrite_gamma..linear_argcsg|]}|fqSrgrgr)rr~rgrhrrrz Gammas partially over the strip.)evaluatertza is not an integerr)6rrrErrpras_independentrr8r6r9r7rOnerallrr^rrrrras_numer_denomr make_argsrziprris_Powrr(baser* is_Integerr%rrUrLTrSrW all_rootsr NegativeOnerzr TypeErrorrangeHalfrrr)-r|r~rrrZ s_multipliersgr$r_r}Z s_multiplierfacexponentnumerdenomrpfacsZdfacsZ numer_gammasZ denom_gammas exponentialsZugammasZlgammasZufacsrrZexp_rrrsrZgamma1Zgamma2fac_anapbmbqZgammasplusminusnewaZnewckrg)rrrrr|rrr~rh_rewrite_gammasR?               $                        &              &&     r(c s\tdd|dd|t}t|t|t|fD]}|jrfdd|jD}dd|D}dd|D}t|}st|| t d }| |t |fSz$t |d d \} } } } } WntyYq0Yn0zt| | | | }WntyYq0Yn0r"|}nzd d lm}||}Wn tyZtd |dYn0|jrt|jdkrt t| |jd jd t t| |jd jd }tt|j|jtkg}|t tt|jt|jkd t|jd ktt|j|jtkg7}t|}|dkr4td |d||  ||fStd |ddS)zs A helper for the real inverse_mellin_transform function, this one here assumes x to be real and positive. rzinverse-mellin-transformT)positivec s g|]}t|ddqS)Fr)_inverse_mellin_transform)rG as_meijergr~stripr}rgrhr s z-_inverse_mellin_transform..cSsg|] }|dqS)rrrgrrrgrgrhrrcSsg|] }|dqS)rrgr/rgrgrhrr)gensrrr) hyperexpandrzCould not calculate integralFzdoes not convergerN) rJrewriterErTrr rrprrr@rrOr(r^rG ValueErrorrr1rzrrr%r$argumentdeltarrNr!r#r#nu)rr~x_r.r-rrrrrrCerr+hr1rrgr,rhr*sZ $      * r*Nc@sHeZdZdZdZedZedZddZe ddZ d d Z d d Z 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. rNonercKs8|durtj}|durtj}tj||||||fi|Srx)r<_none_sentinelrn__new__)clsrr~r}rroptsrgrgrhr?Ms zInverseMellinTransform.__new__cCs:|jd|jd}}|tjur$d}|tjur2d}||fS)Nr2)rpr<r>)rbrrrgrgrhfundamental_stripTs   z(InverseMellinTransform.fundamental_stripc Ks|ddtdur0tttttttt t t t t h at|D].}|jr8||r8|jtvr8td|d|q8|j}t||||fi|S)NrTrzComponent %s not recognised.)r_allowedr(rEr8r6r9r7r+r-r.r,r!r"r is_Functionrrr^rCr*)rbrr~r}rr|r.rgrgrhr]s  z)InverseMellinTransform._compute_transformcCsJ|jj}t||| ||tjtj|tjtjfdtjtjSNrt)rf_crIr ImaginaryUnitrPi)rbrr~r}rrgrgrhrms   z#InverseMellinTransform._as_integralN) rirjrkrlrrr>rGr?rrCrrrgrgrgrhr<?s  r<cKs$t||||d|djfi|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 rrr)r<r)rr~r}r.rrgrgrhinverse_mellin_transformss5rJcsfddfddfddfdd}d d }d d lm}||}||t}||tfd d}||t|}t|S)a Naively simplify some conditions occurring in ``expr``, given that `\operatorname{Re}(s) > a`. Examples ======== >>> from sympy.integrals.transforms import _simplifyconds as simp >>> from sympy.abc import x >>> from sympy import sympify as S >>> simp(abs(x**2) < 1, x, 1) False >>> simp(abs(x**2) < 1, x, 2) False >>> simp(abs(x**2) < 1, x, 0) Abs(x**2) < 1 >>> simp(abs(1/x**2) < 1, x, 1) True >>> simp(S(1) < abs(x), x, 1) True >>> simp(S(1) < abs(1/x), x, 1) False >>> from sympy import Ne >>> simp(Ne(1, x**3), x, 1) True >>> simp(Ne(1, x**3), x, 2) True >>> simp(Ne(1, x**3), x, 0) Ne(1, x**3) cs&|kr dS|jr"|jkr"|jSdSr)r rr()exrrgrhpowers z_simplifyconds..powercs|r|rdSt|tr,|jd}t|tr@|jd}|r\d|d|S|}|durpdSzP|dkrt|t|kdkrWdS|dkrt|t|kdkrWdSWntyYn0dS)z_ Return True only if |ex1| > |ex2|, False only if |ex1| < |ex2|. Else return None. NrrrTF)rrr%rpr)ex1ex2r)rbiggerrLr~rgrhrOs$         z_simplifyconds..biggercsH|jst|tr |js(t|ts(||kS||}|dur@| S||kS)z simplify x < y N) is_positiverr%)r}yrrOrgrhreplies z_simplifyconds..repliecs ||}|dvrdSt||S)NTFT)r)r}rQrrRrgrhreplues z_simplifyconds..repluecWs|dvrt|S|j|S)NrT)boolr)rKrprgrgrhreplsz_simplifyconds..replr) collect_abscs ||Srxrg)r}rQ)rSrgrhrrz _simplifyconds..)sympy.simplify.radsimprXrrrr)rr~rrUrWrXrg)rrOrLrSr~rh_simplifycondss     rZcCst||tS)zs Expand an expression involving DiractDelta to get it as a linear combination of DiracDelta functions. )rQrr?rrgrgrhexpand_dirac_deltasr\cs:tdtdgd}g}g}zt\}}WntyLtddYn0|D]j\} } | t|} | r|| d| |qV| j d dj rtddqV|| | qVt t t t |g|Rtjtjft |} | ts"t| |tjtjfS| js6tdd| j d\} } | tr\tdd fd d fd d t| D}dd |D}|sdd |D}tt|}dd|jfddd|stdd|d\}}fdd}|rt| |} t||}t| |||t||fS)z The backend function for Laplace transforms. This backend assumes that the frontend has already split sums such that `f` is to an addition anymore. r~rexcludeLaplacez'could not expand DiracDelta expressionsrznot implemented yet.rrc sddlm}tj}tj}tt|}tdtgd\}}}}}} } |t t |||k|t t |||kt t |||||kt t |||||kt t t |||||kt t t |||||kf} |D]} tj } g}t| D]F}|jr0|jjvr0|j}|jrNt|ttfrN|j}| D]}||rRqpqRr|jr||tdkrt| dk}||t|t t | |t || dks.|t|t t || ||t || dkst||tt t t || ||t || dkrtfdd|||| | fDrt|k}|tdd t}|jr|jd vs| s| s||g7}q||}|jr |jd vr.||g7}q|j!krHt"d d n t#|j!| } q| tj urpt$| |}qt%|t&|}q||jr|j'n|fS) z7 Turn ``conds`` into a strip and auxiliary conditions. rrzp q w1 w2 w3 w4 w5r@r^rtc3s|]}|jVqdSrx)rP)rwildrrgrhr_rz<_laplace_transform..process_conds..cSs|dSr)r rrrgrgrhrbrz;_laplace_transform..process_conds..rr_zconvergence not in half-plane?)(rrrrrrLrKrrr%r$r'r&rrMrrhsrvreversedrrr reversedsignmatchrPrr#r6r rrrrrr^r2r1rOrN canonical)rrrrrrw1w2Zw3Zw4Zw5patternsrrrrpatrr)r|r~rrbrhr9s       &:4"(      z)_laplace_transform..process_condscsg|] }|qSrgrgrrrgrhrxrz&_laplace_transform..cSs*g|]"}|ddkr|dtjur|qS)rrFr)rrrrgrgrhryrcSsg|]}|ddkr|qS)rrFrgrrgrgrhr{rcSs|dvr dS|S)NrTrrr[rgrgrhcnt~sz_laplace_transform..cntcs|d |dfSNrrrrgr)rlrgrhrrz$_laplace_transform..rrcs |Srx)rr[)r~rrgrhsbssz_laplace_transform..sbs)rrr\rRr^itemsrfr?rrrpis_zerorrHr(rrrrrIrrrrrMrrrrZr)r|rrrrZ deltazeroZ deltanonzeroZ integratableZ deltadictZ dirac_funcZ dirac_coeffrrrrZconds2rrnrg)rlr|rr~rrrh_laplace_transformsf      ?     rqcsT|j}t|j}t|jdkr"|Sfdd|D}|jrH||S||SdS)a This is an internal helper function that traverses through the epression tree of `f(t)` and collects arguments. The purpose of it is that anything like `f(w*t-1*t-c)` will be written as `f((w-1)*t-c)` such that it can match `f(a*t+b)`. rcsg|]}t|qSrg_laplace_deep_collect)rr$rrgrhrrz)_laplace_deep_collect..N)rrrprrcollect)r|rrrprgrtrhrss rsc ]s(tdgd}tdgd}tdgd}tdgd}tdgd}fdd}|||tjtj|ft||t| ||t|tt|d k|d kt|d k|d ktj|ft||td tt|d k|d kt|d k|d ktj|fd d |tjtj|ft ||t| |||t|d k|d ktj|ft ||d t| |||t|d k|d ktj|ft ||d |t|d k|d ktj|ft ||d t|d k|d ktj|fd |d tjtj|fd ||t| || t | ||||d ktj|fd t ||t |t |t|||t t |||||d ktj|ft |t t |t t |t||t t ||tjtj|f||td  d d |td  d d t ||td d t|||t t |||||d ktj|ftd d |d t |td d t |td d t||t t ||tjtj|fd |t dt |td d t||t t ||tjtj|f|t|d ||d |d ktj|f|||t|d |||t| ||||d |t|d k|d ktj|f||||t|d t| |||d ktj|ft||t| ||tj||ft||t| ||d tj||f|t|t|d |||d |d k||ft| d t t d|t|d d|t |t d||d ktj|ft| d d d |d t t d|td d |t |t d|tjtj|ft| d t ||td d t |||d ktj|ft t| td d t t |d d d t ||tdt |||d ktj|ft| t t t |tdt |||d ktj|ft| t t t |tdt |||d ktj|f|t| d |||d d t|d d t |||d ktj|ftdt ||d t t ||td  d t||t t ||tjtj|ftdt |t t |td d t||t t ||tjtj|ft|||d |d tjt||ft|d d |d |d d|d |d tjtd ||ft|t||||d tj||f|t|t|d d ||| d ||| d |dkt||ftd t |t t ||t |t||tjtj|ft td t |t td d |td d |d |t||tt |||td d |dtjtj|ftd t |t t td d |td  d t||tt ||tjtj|ftt |d t t td d d |td  d t||d tjtj|ft|||d |d tjt||ft|d |d d |d |d d|d |d tjtd ||f|t|t|d d ||| d ||| d |d kt||ftd t |d |t t ||t |t||tt ||tjtj|ft td t |t td d |td d |d |t||tjtj|ftd t |t t td d |td  d t||tjtj|ftt |d t t td d d |td  d t||d tjtj|ft|t||tj ||d ktj|ftd |t|| |t | |tjtj|ft||t|t|||||t | ||||d ktj|ftt t t | td|tjtjtj|f|tt|d || d t|d t||d ktj|ft|d t||tjd t d d||d ktj|ft| tt||tj ||tj| |ft|||d |d tjtj|ftt|||d |d tt |d ||d ktj|ft|t||tjtj|ft|d td d|d |d dtjtj|ft|d d |td |||td d|d |d dtjtj|ftd t |t t ||t |t| ||d ktj|ftd t |t tt |||d ktj|ft|||d |d tjtj|ft|d |d d |d |d d|d |tjtj|ft td t |t t d |td d |d |t| ||d ktj|ftd t |t t t |t| ||d ktj|ft|t|d ||||d ||d |d ||d tjtj|ft|t|||d |d |d |d ||d |d ||d tjtj|ft|t|||d |d |d |d ||d |d ||d tjtj|ft|t||||d |d tj||ft|t|||||d |d tj||ft|t|d d |d t |d |||d ktj|ftt |t |t ||||d ktj|ft|tt |t |t ||||d k||ftt |d d tt || ||d ktj|ft t |t ||t |t ||||d ktj|ft|t t |d |t |||d ktj|ft t |d tt || ||d ktj|ft||||t |d |d |t |d |d |t|d k|d ktj|f|t||d |t t t|tj|||d |d | tjtt|d k|tj kt||tj|f|t||d |d t t t|td d ||||d |d | td d tt|d k|d kt||d tj|ftd d t |t| |||d ktj|f|t|d t |||d || d t| |tt|d k|d kt||tjtj|ftd |t d |t|||t |d |d t |d |d |d ktj|ft||||t |d |d |t |d |d |t|d k|d kt||f|t||d |t t t|tj|||d |d | tjtt|d k|tj kt||t||f|t||d |d t t t|td d ||||d |d | td d tt|d k|d kt||d t||f|t|d t |||d || d t||tt|d k|d kt||tjtj|ftd |dt t ||t |d |d |d ktj|ftd |t|t |d |d t |d |d |d kt||fgW}|S)z This is an internal helper function that returns the table of Laplace transfrom rules in terms of the time variable `t` and the frequency variable `s`. It is used by `_laplace_apply_rules`. rr]rrtauomegacs t|Srxrrrrtrgrhrrz&_laplace_build_rules..rrrrtr2rg?rB)!rrrrr?r(r%rNrOr@rCr3rrBrErFr=r-r)rAr+ EulerGammarDr8r,r:r6r<rrr;r>r/) rr~rrrrvrwZdcoZlaplace_transform_rulesrgrtrh_laplace_build_ruless **   ( 6 2 X B .  6"  6 B  $ B   0 @ .   &2" ` < 4   .2: 8 , 4    4  , $    &    6 $    * 6  6 B B  *    "    6@&T& &(6  6@(T($( &  .ir|cKs$|dd }|r|||fS|SdS)z Internal helper function that will return `(f, a, c)` unless `**hints` contains `noconds=True`, in which case it will only return `f`. rFN)get)r|rrrrrgrgrh _laplace_crs r~c s|dd}tdgd}tddd}|jdd \}} | |} | r| |jd } | |} | r| |d krtd td || | ftd | |dkr|dkrtfdd| | t Ds|t | | ||dS|t | | |fi|Snrt| | || |fd|i|} z"| \}}}|| ||||fWSty|| || YS0dS)a This internal helper function tries to apply the time-scaling rule of the Laplace transform and returns `None` if it cannot do it. Time-scaling means the following: if $F(s)$ is the Laplace transform of, $f(t)$, then, for any $a>0$, the Laplace transform of $f(at)$ will be $\frac1a F(\frac{s}{a})$. This scaling will also affect the transform's convergence plane. rTrr]rrrnargsFas_Addr_laplace_apply_rules match: f: %s ( %s, %s )z1 rule: amplitude and time scaling (1.1, 1.2)c3s|]}|VqdSrx)rrrtrgrhr8rz*_laplace_rule_timescale..rrN)rrrrrfrprur]rrr rqrLaplaceTransform_laplace_apply_rulesr)r|rr~rrrrrr'rma1r$ma2Lrrrrgrtrh_laplace_rule_timescale!s>    $ rcKsh|ddtd|gd}td|gd}td}tddd }|j|d d \} } | t||} | rd| |||} | |jd |||} | rd| |d krd| rd| || |krdtd td|| | | ftdt | | |||fd|i|}z,|\}}}| t | | ||||fWSt yb| t | | ||YS0dS)z This internal helper function tries to transform a product containing the `Heaviside` function and returns `None` if it cannot do it. rTrr]rrQrrrrFrrrz f: %s ( %s, %s, %s )z rule: time shift (1.3)rN) rrrrrfr@rprur]rrr(r)r|rr~rrrrrQrr'rrrZma3rrrrrgrgrh_laplace_rule_heavisideHs*  ," " rcKs|ddtd|gd}td}td}|j|dd\}} | t||} | r| ||||} | rtd td || | ftd t| |||| |fd |i|} z| \} }}| || ||fWSty| YS0d S)z This internal helper function tries to transform a product containing the `exp` function and returns `None` if it cannot do it. rTrr]rQzFrrrz# rule: multiply with exp (1.5)rN) rrrrfr(rur]rr)r|rr~rrrrQrr'rrrrrrrrgrgrh_laplace_rule_expds& $   rcKsB|dd}td|gd}td}td}|j|dd\} } t|d d d d ft|d d d d ft|d t d tft|dd d tfg} | D]} | \} }}}}| | |}|r|| |||}|rt dt d|||ft d| j |ft ||||fd|i|}zv|\}}}|d kr4t ||}nd}||||||||||||||d|||fWSty:|dkr|dkr||||||||||||||dYS||||||||||||||dYSYq0qdS)z This internal helper function tries to transform a product containing a trigonometric function (`sin`, `cos`, `sinh`, `cosh`, ) and returns `None` if it cannot do it. rTrr]rQrFrz1.6rrrz1.7z1.81.9rrz! rule: multiply with %s (%s)rrrtN)rrrr-r+r8rr6rfrur]rrr%rrr)r|rr~rrrrrQrr'rZ trigrulesZtrigrulefmr7s1s2sdrrrrrrZcp_shiftrgrgrh_laplace_rule_trig~sV  "     rc KsR|ddtd|gd}td}td|gd}tddd }||t|||f} | rN| |jd |krN| |jrNtd td |ftd g} t| |D]b} | d kr| | | |d }n t| | ||| f |d }| || || d|q|| |t | | |||fd|i|} | || t | SdS)z This internal helper function tries to transform an expression containing a derivative of an undefined function and returns `None` if it cannot do it. rTrr]rQrrrrrrr f: %sz( rule: time derivative (1.11, 1.12)rN)rrrrfr rp is_integerr]rrrrrr) r|rr~rrrrQrrrrr'rrgrgrh_laplace_rule_diffs*  &  $rc Ks:|j|dd\}}t||}|D]\}} } } } | ||} | r tdtd|ftd|| fz`td| f| | }td| |f|dkrt|| | | | tjfi|WSWq tytd Yq 0q | t rd St t t ttg}|D]0}||||fd |i|}|d ur|Sqd S) aM Helper function for the class LaplaceTransform. This function does a Laplace transform based on rules and, after applying the rules, hands the rest over to `_laplace_transform`, which will attempt to integrate. If it is called with `doit=False`, then it will instead return `LaplaceTransform` objects. Frrrz rule: %s o---o %sz try %sz check %s -> %sTz#_laplace_apply_rules did not match.Nr)rr|rfr]xreplacer~rr Exceptionrr?rrrrr)r|rr~rrr'rZ simple_rulesZt_domZs_domcheckplaneprepmarZ prog_rulesZp_rulerrgrgrhrs<        rc@s4eZdZdZdZddZddZddZd d Zd S) rz Class representing unevaluated Laplace transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute Laplace transforms, see the :func:`laplace_transform` docstring. r_cKsdt|||fi|}|dur\|dd}td|ftd|ft|||fd|i|S|SdS)NrTz0_laplace_apply_rules could not match function %sz hints: %s)rrr]rq)rbr|rr~rrrrgrgrhrs z#LaplaceTransform._compute_transformcCs"t|t| ||tjtjfSrx)rIr(rrr)rbr|rr~rgrgrhrszLaplaceTransform._as_integralcCsVg}g}|D]\}}||||q t|}t|}|dkrNtddd||fS)NFr_zNo combined convergence.)rrOr1r^)rbrrZplanesrrrgrgrhrs   z LaplaceTransform._collapse_extracKsl|j}td|f|j}|j}d}|jsdt|}z|j|||fi|}Wntybd}Yn0||fS)Nz----> _try_directly: %s)rar]rsrurrrr^)rbrrt_rrrgrgrhrs  zLaplaceTransform._try_directlyN) rirjrkrlrrrrrrgrgrgrhrs    rc  std|ft|trt|drdd }|r|rtddddtt&|fd d Wd S1s0Ynjfd d |D}|rt |\}}} t |g|j |R} | t |t | fSt |g|j |RSt|jfiS)ak Compute the Laplace Transform `F(s)` of `f(t)`, .. math :: F(s) = \int_{0^{-}}^\infty e^{-st} f(t) \mathrm{d}t. Explanation =========== For all sensible functions, this converges absolutely in a half-plane .. math :: a < \operatorname{Re}(s) This function returns ``(F, a, cond)`` where ``F`` is the Laplace transform of ``f``, `a` is the half-plane of convergence, and `cond` are auxiliary convergence conditions. The implementation is rule-based, and if you are interested in which rules are applied, and whether integration is attemped, you can switch debug information on by setting ``sympy.SYMPY_DEBUG=True``. The lower bound is `0-`, meaning that this bound should be approached from the lower side. This is only necessary if distributions are involved. At present, it is only done if `f(t)` contains ``DiracDelta``, in which case the Laplace transform is computed implicitly as .. math :: F(s) = \lim_{\tau\to 0^{-}} \int_{\tau}^\infty e^{-st} f(t) \mathrm{d}t by applying rules. If the integral cannot be fully computed in closed form, this function returns an unevaluated :class:`LaplaceTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. If ``noconds=True``, only `F` will be returned (i.e. not ``cond``, and also not the plane ``a``). .. deprecated:: 1.9 Legacy behavior for matrices where ``laplace_transform`` with ``noconds=False`` (the default) returns a Matrix whose elements are tuples. The behavior of ``laplace_transform`` for matrices will change in a future release of SymPy to return a tuple of the transformed Matrix and the convergence conditions for the matrix as a whole. Use ``legacy_matrix=False`` to enable the new behavior. Examples ======== >>> from sympy import DiracDelta, exp, laplace_transform >>> from sympy.abc import t, s, a >>> laplace_transform(t**4, t, s) (24/s**5, 0, True) >>> laplace_transform(t**a, t, s) (gamma(a + 1)/(s*s**a), 0, re(a) > -1) >>> laplace_transform(DiracDelta(t)-a*exp(-a*t),t,s) (s/(a + s), Max(0, -a), True) See Also ======== inverse_laplace_transform, mellin_transform, fourier_transform hankel_transform, inverse_hankel_transform z$ ***** laplace_transform(%s, %s, %s) applyfuncrFz Calling laplace_transform() on a Matrix with noconds=False (the default) is deprecated. Either noconds=True or use legacy_matrix=False to get the new behavior. rz#deprecated-laplace-transform-matrix)deprecated_since_versionactive_deprecations_targetcst|fiSrxlaplace_transform)fijrr~rrgrhrrz#laplace_transform..Ncs g|]}t|fiqSrgr)rrrrgrhrrz%laplace_transform..)r]rrPhasattrr}rYr[rZrr typeshaper1rOrr) r|rr~Z legacy_matrixrrZelements_transelementsavals conditionsZ f_laplacergrrhr.s$B 6rc sddlm}mtdddfdd}|r>|}|jrxtfdd |jD}t | |dfSz(t |t  d t jfdd d \}}Wntyd }Yn0|d ur$||}|d urtd |d|jr|jd\}}|trtd |dnt j}|t|}|jr<| ||fStdt jffdd } |t| }dd} |t | }t | ||fS)z6 The backend function for inverse Laplace transforms. r)meijerint_inversion_get_coeff_exprTrcst|dkrt|S|djdj}|\}}|djd}|djd}tdt|||t|dt||S)z3 Simplify a piecewise expression from hyperexpand. r2rtrrr)rr4rpr5r@r%)rpr$rre1e2)rrrgrhpw_simps z+_inverse_laplace_transform..pw_simpcsg|]}t|qSrg)_inverse_laplace_transform)rX)rr~rrrgrhrsz._inverse_laplace_transform..NF)rrInverse Laplacerz(inversion integral of unrecognised form.ucs|t }|r&t||Sddlm}||dk}|jkrbt|j}t||St|j}t| |SdS)Nrr) rr(rr@rrrr)r)r$H0rrrelr')rrrgrhsimp_heavisides      z2_inverse_laplace_transform..simp_heavisidecSs tt|Srx)r r()r$rgrgrhsimp_expsz,_inverse_laplace_transform..simp_exp)sympy.integrals.meijerintrrris_rational_functionapartrrrprrrJr(rrr^rrrIrrr4rr@) rr~rrrrrr|rrrrg)rrr~rrrrhrsH            rc@sHeZdZdZdZedZedZddZe ddZ d d Z d d Z d S)InverseLaplaceTransformz Class representing unevaluated inverse Laplace transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute inverse Laplace transforms, see the :func:`inverse_laplace_transform` docstring. rr=rcKs(|durtj}tj|||||fi|Srx)rr>rnr?)r@rr~r}rrArgrgrhr?szInverseLaplaceTransform.__new__cCs|jd}|tjurd}|SNr2)rprr>)rbrrgrgrhfundamental_planes  z)InverseLaplaceTransform.fundamental_planecKst||||jfi|Srx)rr)rbrr~rrrgrgrhrsz*InverseLaplaceTransform._compute_transformcCsL|jj}tt|||||tjtj|tjtjfdtjtjSrF)rfrGrIr(rrHrrI)rbrr~rrrgrgrhrs  z$InverseLaplaceTransform._as_integralN) rirjrkrlrrr>rGr?rrrrrgrgrgrhrs  rc sFt|tr,t|dr,|fddSt|jfiS)a Compute the inverse Laplace transform of `F(s)`, defined as .. math :: f(t) = \frac{1}{2\pi i} \int_{c-i\infty}^{c+i\infty} e^{st} F(s) \mathrm{d}s, for `c` so large that `F(s)` has no singularites in the half-plane `\operatorname{Re}(s) > c-\epsilon`. Explanation =========== The plane can be specified by argument ``plane``, but will be inferred if passed as None. Under certain regularity conditions, this recovers `f(t)` from its Laplace Transform `F(s)`, for non-negative `t`, and vice versa. If the integral cannot be computed in closed form, this function returns an unevaluated :class:`InverseLaplaceTransform` object. Note that this function will always assume `t` to be real, regardless of the SymPy assumption on `t`. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Examples ======== >>> from sympy import inverse_laplace_transform, exp, Symbol >>> from sympy.abc import s, t >>> a = Symbol('a', positive=True) >>> inverse_laplace_transform(exp(-a*s)/s, s, t) Heaviside(-a + t) See Also ======== laplace_transform, _fast_inverse_laplace hankel_transform, inverse_hankel_transform rcst|fiSrx)inverse_laplace_transform)ZFijrrr~rrgrhr0rz+inverse_laplace_transform..)rrPrrrr)rr~rrrrgrrhrs+rcsltdtgd\fddfddfdd fd d fd d |S) zEFast inverse Laplace transform of rational function including RootSumza, b, nr`csR|s|S|jr|S|jr*|S|jr8|St|trJ|StdSrx)rris_Mulr rrXrzr:)_ilt_add_ilt_mul_ilt_pow _ilt_rootsumr~rgrh_ilt8s  z#_fast_inverse_laplace.._iltcs|jt|jSrx)rmaprprrrgrhrFsz'_fast_inverse_laplace.._ilt_addcs$|\}}|jrt||Srx)rrrz)r:rr)rr~rgrhrIsz'_fast_inverse_laplace.._ilt_mulcs|}|dur|||}}}|jr||dkr|| dt|| || t| S|dkrt|| |StdSrm)rfrr(rErz)r:rfnmamr")rrrr~rrgrhrOs4z'_fast_inverse_laplace.._ilt_powcs,|jj}|jj\}t|jt|t|Srx)funr variablesrXpolyrrV)r:rvariablerrgrhrYs z+_fast_inverse_laplace.._ilt_rootsum)rr)r:r~rrg) rrrrrrrrr~rrh_fast_inverse_laplace4s  rc Cst||t|tj|||tjtjf}|tsHt||tj fSt||tjtjf}|tjtjtj fvsz|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)rHr(rrHrrrrIrrNaNr^rrp) r|r}r'rrrrrZ integral_frrgrgrh_fourier_transformes .     rc@s0eZdZdZddZddZddZdd Zd S) FourierTypeTransformz# Base class for Fourier transforms.cCstd|jdSNz,Class %s must implement a(self) but does notrzrfrqrgrgrhrszFourierTypeTransform.acCstd|jdSNz,Class %s must implement b(self) but does notrrqrgrgrhrszFourierTypeTransform.bcKs&t||||||jjfi|Srx)rrrrfrrbr|r}r'rrgrgrhrs  z'FourierTypeTransform._compute_transformcCs>|}|}t||t|tj|||tjtjfSrx)rrrIr(rrHrr)rbr|r}r'rrrgrgrhrsz!FourierTypeTransform._as_integralNrirjrkrlrrrrrgrgrgrhrs rc@s$eZdZdZdZddZddZdS)FourierTransformz Class representing unevaluated Fourier transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute Fourier transforms, see the :func:`fourier_transform` docstring. ZFouriercCsdSrrgrqrgrgrhrszFourierTransform.acCs dtjS)NrxrrIrqrgrgrhrszFourierTransform.bNrirjrkrlrrrrgrgrgrhrs rcKst|||jfi|S)a Compute the unitary, ordinary-frequency Fourier transform of ``f``, defined as .. math:: F(k) = \int_{-\infty}^\infty f(x) e^{-2\pi i x k} \mathrm{d} x. Explanation =========== If the transform cannot be computed in closed form, this function returns an unevaluated :class:`FourierTransform` 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 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 )rrr|r}r'rrgrgrhfourier_transforms'rc@s$eZdZdZdZddZddZdS)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 FouriercCsdSrrgrqrgrgrhrszInverseFourierTransform.acCs dtjSrFrrqrgrgrhrszInverseFourierTransform.bNrrgrgrgrhrs rcKst|||jfi|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 )rrrr'r}rrgrgrhinverse_fourier_transforms'rc Cst|||||||tjtjf}|tsBt||tjfS|jsTt ||d|j d\}} |trxt ||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) rHrrrrrIrrrr^rp) r|r}r'rrKrrrrrgrgrh_sine_cosine_transform s (    rc@s0eZdZdZddZddZddZdd Zd S) SineCosineTypeTransformzK Base class for sine and cosine transforms. Specify cls._kern. cCstd|jdSrrrqrgrgrhr7 szSineCosineTypeTransform.acCstd|jdSrrrqrgrgrhr; szSineCosineTypeTransform.bcKs,t||||||jj|jjfi|Srx)rrrrf_kernrrrgrgrhr@ s z*SineCosineTypeTransform._compute_transformcCs@|}|}|jj}t|||||||tjtjfSrx)rrrfrrIrrr)rbr|r}r'rrrrgrgrhrF sz$SineCosineTypeTransform._as_integralNrrgrgrgrhr1 s rc@s(eZdZdZdZeZddZddZdS) 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. ZSinecCstdttSrFr3rrqrgrgrhrZ szSineTransform.acCstjSrxrrrqrgrgrhr] szSineTransform.bN rirjrkrlrr8rrrrgrgrgrhrM s  rcKst|||jfi|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 )rrrrgrgrhsine_transforma s$rc@s(eZdZdZdZeZddZddZdS)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 SinecCstdttSrFrrqrgrgrhr szInverseSineTransform.acCstjSrxrrqrgrgrhr szInverseSineTransform.bNrrgrgrgrhr s  rcKst|||jfi|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 )rrrrgrgrhinverse_sine_transform s%rc@s(eZdZdZdZeZddZddZdS)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. ZCosinecCstdttSrFrrqrgrgrhr szCosineTransform.acCstjSrxrrqrgrgrhr szCosineTransform.bN rirjrkrlrr6rrrrgrgrgrhr s  rcKst|||jfi|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 )rrrrgrgrhcosine_transform s$rc@s(eZdZdZdZeZddZddZdS)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 CosinecCstdttSrFrrqrgrgrhr szInverseCosineTransform.acCstjSrxrrqrgrgrhr szInverseCosineTransform.bNrrgrgrgrhr s  rcKst|||jfi|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 )rrrrgrgrhinverse_cosine_transform s$rcCst|t|||||tjtjf}|ts@t||tjfS|j sRt ||d|j d\}}|trvt ||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) rHr<rrrrrIrrrr^rp)r|rr'r7rrrrrgrgrh_hankel_transform> s&    rc@s4eZdZdZddZddZddZedd Zd S) HankelTypeTransformz+ Base class for Hankel transforms. cKs$|j|j|j|j|jdfi|Sr)rrarsrurp)rbrrgrgrhrY szHankelTypeTransform.doitcKst|||||jfi|Srx)rr)rbr|rr'r7rrgrgrhr` sz&HankelTypeTransform._compute_transformcCs&t|t|||||tjtjfSrx)rIr<rrr)rbr|rr'r7rgrgrhrc sz HankelTypeTransform._as_integralcCs||j|j|j|jdSr)rrarsrurprqrgrgrhrf s zHankelTypeTransform.as_integralN) rirjrkrlrrrrrrgrgrgrhrT s rc@seZdZdZdZdS)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. ZHankelNrirjrkrlrrgrgrgrhrn s rcKst||||jfi|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 )rr)r|rr'r7rrgrgrhhankel_transform{ s.rc@seZdZdZdZdS)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 HankelNrrgrgrgrhr s rcKst||||jfi|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 )rr)rr'rr7rrgrgrhinverse_hankel_transform s.r)F)T)T)T)T)T)T)T)T)T)N)T)T)T)rl functoolsrr itertoolsr sympy.corerrrsympy.core.addrsympy.core.functionr r r r r rrrrsympy.core.mulrsympy.core.numbersrrsympy.core.relationalrrrrrrsympy.core.sortingrrsympy.core.symbolrrrsympy.core.traversalr (sympy.functions.combinatorial.factorialsr!r"$sympy.functions.elementary.complexesr#r$r%r&r'&sympy.functions.elementary.exponentialr(r)r*%sympy.functions.elementary.hyperbolicr+r,r-r.r/#sympy.functions.elementary.integersr0(sympy.functions.elementary.miscellaneousr1r2r3$sympy.functions.elementary.piecewiser4r5(sympy.functions.elementary.trigonometricr6r7r8r9r:sympy.functions.special.besselr;r<r=r>'sympy.functions.special.delta_functionsr?r@'sympy.functions.special.error_functionsrArBrC'sympy.functions.special.gamma_functionsrDrErFsympy.functions.special.hyperrGsympy.integralsrHrIrrJsympy.logic.boolalgrKrLrMrNrOsympy.matrices.matricesrPZsympy.polys.matrices.linsolverQrRsympy.polys.polyrootsrSsympy.polys.polytoolsrTrUsympy.polys.rationaltoolsrVsympy.polys.rootoftoolsrWrXsympy.utilities.exceptionsrYrZr[sympy.utilities.iterablesr\sympy.utilities.miscr]rzr^rnrrZ_nocondsrrrrrr4rr(r*rDr<rJrZr\rqrsr|r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrgrgrgrhs  ,           D!,-- :4<X w '   5  )5 b P# 01 *. '('+  1