o 8Va @sdZddlmZddlmZmZmZmZmZm Z m Z ddl m Z ddl mZmZddlmZddlmZmZmZddlmZdd lmZdd lmZdd lmZdd lmZm Z dd l!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3Gddde4Z5GdddeZ6ddl7m8Z8ddZ9ddZ:e:dZ;ddZd%d&Z?d'd(Z@Gd)d*d*eAZBd+d,ZCe:d dsd-d.ZDd/aEGd0d1d1e6ZFd2d3ZGd4d5ZHd6d7ZIe;dtd8d9ZJGd:d;d;e6ZKdtdd?ZMGd@dAdAe6ZNdudBdCZOdDdEZPe:d dtdFdGZQGdHdIdIe6ZRGdJdKdKeRZSdLdMZTGdNdOdOeRZUdPdQZVddRlmWZWmXZXmYZYmZZZe:d dtdSdTZ[GdUdVdVe6Z\GdWdXdXe\Z]dYdZZ^Gd[d\d\e\Z_d]d^Z`Gd_d`d`e\ZadadbZbGdcdddde\ZcdedfZde:d dtdgdhZeGdidjdje6ZfGdkdldlefZgdmdnZhGdodpdpefZidqdrZjd/S)vz Integral Transforms )reduce)symbolsWildRootSumLambdatogetherexpgamma)S)iterableordered)Function) _canonicalGeGtoo)Dummy) DiracDeltaMax) integrateIntegral)_dummy)to_cnf conjuncts disjunctsOrAnd)simplify)default_sort_key)SymPyDeprecationWarning) MatrixBase) _lin_eq2dictPolyNonlinearErrorcs 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)selfZ transformr(msg __class__>> from sympy.integrals.transforms import LaplaceTransform >>> LaplaceTransform._name 'Laplace' Implement ``self._collapse_extra`` if your function returns more than just a number and possibly a convergence condition. cC |jdS)z! The function to be transformed. rargsr)r-r-r.r(H zIntegralTransform.functioncCr5)z; The dependent variable of the function to be transformed. r6r8r-r-r.function_variableMr9z#IntegralTransform.function_variablecCr5)z% The independent transform variable. r6r8r-r-r.transform_variableRr9z$IntegralTransform.transform_variablecCs|jj|jh|jhS)zj This method returns the symbols that will exist when the transform is evaluated. )r( free_symbolsunionr=r;r8r-r-r.r>WszIntegralTransform.free_symbolscKtNNotImplementedErrorr)fxshintsr-r-r._compute_transform`z$IntegralTransform._compute_transformcCr@rArBr)rErFrGr-r-r. _as_integralcrJzIntegralTransform._as_integralcCs$t|}|dkrt|jjdd|S)NF)rr%r,name)r)extracondr-r-r._collapse_extrafsz!IntegralTransform._collapse_extrac sddlm}m}m}ddlm}dd}tfddj |D }|rAzj jj j fiWSt y@Ynwj}|jsK||}|jr|d<fdd |jD} g} g} | D].} t| tsm| g} | | dt| d kr| | d qct| d kr| | d d g7} qc|| } | s| Sz| } t| rt| gt| WS| | fWSt yYnw|rt jjjd|j \} }| j||gtjd d S) 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, don't 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)``. r)Add expand_mulMul) AppliedUndefneedevalFc3s|] }|jVqdSrA)hasr;).0funcr8r-r. sz)IntegralTransform.doit..cs6g|]}j|gtjddjdiqS)r:Nr-)r,listr7doitrXrFrHr)r-r. s.z*IntegralTransform.doit..r<r:N)sympyrRrSrTsympy.core.functionrUpopanyr(atomsrIr;r=r%is_Addr7 isinstancetupleappendlenrQr r,_name as_coeff_mulr[)r)rHrRrSrTrUrVZ try_directlyfnresrOressrFcoeffrestr-r^r.r\lsh              &zIntegralTransform.doitcCs||j|j|jSrA)rLr(r;r=r8r-r-r. as_integrals zIntegralTransform.as_integralcOs|jSrA)rq)r)r7kwargsr-r-r._eval_rewrite_as_Integralsz+IntegralTransform._eval_rewrite_as_IntegralN)r/r0r1r2propertyr(r;r=r>rIrLrQr\rqrsr-r-r-r.r41s"    K  r4)_solve_inequalitycCs,ddlm}m}|rt|||ddS|S)Nr) powdenestpiecewise_foldT)Zpolar)r`rvrwr)exprr\rvrwr-r-r. _simplifysrycsfdd}|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). cs*ddlm}|dfdd }|S)Nr)wrapsnocondscs|i|}|r |dS|SNrr-)r|r7rrrmrYr-r.wrappersz0_noconds_..make_wrapper..wrapper)Zsympy.core.decoratorsrz)rYrzrdefaultr~r. make_wrappers z_noconds_..make_wrapperr-)rrr-rr. _noconds_s  rFcCst||dtfSr})rr)rErFr-r-r._default_integratorrTc sddlmmmmtdd|||d||}|ts2t| ||t t ft j fS|j s;td|d|jd\}}|trMtd|dfd d fd d t|D}d d |D}|jfddd|sztd|d|d\}} } t| |||| f| fS)z0 Backend function to compute Mellin transforms. r)rerMin count_opsrGzmellin-transformr:Mellincould not compute integralintegral in unexpected formc s6t }t}tj}tt|}tddd}|D]}t}t }g} t|D]M} | dd|} | j rE| j dvsE| sE| |sK| | g7} q#t | |} | j rX| j dvr^| | g7} q#| j |krj| j|}q#| j |}q#|tkr||kr||}q|t kr||kr||}qt|t| }q|||fS)zN Turn ``cond`` into a strip (a, b), and auxiliary conditions. tTrealcSs |dSr}) as_real_imagrFr-r-r.s z:_mellin_transform..process_conds..z==z!=)rr truerrrrreplacesubs is_Relationalrel_oprWrultsgtsrr) rPabauxcondsrca_b_aux_dd_soln)rrrrGr-r. process_condssN           z(_mellin_transform..process_condscg|]}|qSr-r-rXrrr-r.r_+z%_mellin_transform..cSg|] }|ddkr|qS)r<Fr-r]r-r-r.r_,cs|d|d|dfS)Nrr:r<r-rrr-r.r-rz#_mellin_transform..keyno convergence found)r`rrrrrrWrryrrr r is_Piecewiser%r7rsort) rErFs_Z integratorrFrPrrrrr-)rrrrrrGr._mellin_transforms(     & rc@,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. rcKt|||fi|SrA)rrDr-r-r.rIBz"MellinTransform._compute_transformcCst|||d|dtfS)Nr:r)rrrKr-r-r.rLEszMellinTransform._as_integralc Csddlm}m}g}g}g}|D]\\}}} ||g7}||g7}|| g7}q||||ft|f} | dd| ddkdksF| ddkrLtddd| S)Nr)rrr:TFrzno combined convergence.)r`rrrr%) r)rOrrrrrPZsaZsbrrmr-r-r.rQHs   (zMellinTransform._collapse_extraNr/r0r1r2rjrIrLrQr-r-r-r.r6s   rcKt|||jdi|S)aE 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.integrals.transforms import mellin_transform >>> from sympy import 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 Nr-)rr\)rErFrGrHr-r-r.mellin_transformXs*rc Csddlm}m}m}m}|\}} |||}|| |} || || d} |||| | |d| | ||d| |fS)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)rSpiceilingr r:)r`rSrrr r) Zm_nrGrrrSrrr mnrr-r-r. _rewrite_sins %  6rc@seZdZdZdS)MellinTransformStripErrorzF Exception raised by _rewrite_gamma. Mainly for internal use. N)r/r0r1r2r-r-r-r.rsrc;s$ddlm}ddlmm}m}m m}m}m m } m } m } m } m} m}m}m}m}t||g\ fdd}g}|D]#}| sJqB|jd}|jrY| d}| \}}||g7}qB| | ||D]%}| svqn|jd}|jr| d}| \}}||| g7}qndd|D}tj|D] }|js|nqfd d|D}td d |Dsjstd d dt| dd|Dtj}|krt |dkr}n t|dd|D}! |tj|}tj|}d ur|9d ur|9"\}}|#|}|#|}t$t%||dt$t%||d}g}g} g}!g}"g}#fdd|r7|&\rV|!|"}$}%|}&n|"|!}$}%| }& fdd}' ss|&g7}&nj's}t(|rшj'rj)}(j})n|d}(j})|)j*r}*|)dkr|* }*||(|*fgt+|)7}qB|( s|'|)\}}sd|(}(|#|(|g7}#||(|g7}ng, rR }+|+-dkr|+.d}| |+ },t |,|+-kr|/|+},|&|g7}&| fdd|,D7}qB|+0\}}-|&|g7}&|-| }-||-r:|$tj|- dfg7}$|%tj|- fg7}%n|&dg7}&|$tj1|-dfg7}$|%tj1|-fg7}%nt(|r|'jd\}}r|dkrt|| |dks|dkr|| |dkrt2d|$||fg7}$nt(| rψjd}r||| |d|| | }.}/}0n t3|'| \}.}/}0||. f|/ fg7}|&|0g7}&net(|rjd}|| |ddf| | d|dd fg7}nBt(| r jd}|| | d|ddfg7}n't(|r0jd}|| | d|ddf| |dd fg7}n|sE||||| 9}ggggf\}1}2}3}4|!|1|3df|"|4|2dffD]\}5}6}7|5r|5&\}}-|dkr|dkrt+t|}+||+}8|-|+}9|j*st4dt5|+D]}:|5|8|9|:|+fg7}5qr|d| d|+d|+|-tj69}|#|+|g7}#n|d| d|+d|+|-tj6}|#|+| g7}#q]|dkr|67d|-n|77|-|5s`qW||#}|1j8t9d|2j8t9d|3j8t9d|4j8t9d|1|2f|3|4f|||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) r)repeat)Polyr rTrCRootOfrexpandrootsilcmrsincostancotigcd exp_polarcs|}durturdSdur|kSdur |kS|kdkr(dS|kdkr0dS|r4dSjs=js=|jr?dStd)zU Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)rr>r)ris_numer)rrrrr-r.lefts   z_rewrite_gamma..leftr:cSsg|] }|jr t|n|qSr-)is_extended_realabsr]r-r-r.r_)sz"_rewrite_gamma..csg|]}|qSr-r-r])common_coefficientr-r.r_/rcss|]}|j VqdSrA) is_Rationalr]r-r-r.rZ0sz!_rewrite_gamma..ZGammaNzNonrational multipliercSg|]}t|jqSr-)r qr]r-r-r.r_3scSrr-)r pr]r-r-r.r_:TFcstdd|S)NInverse MellinzUnrecognised form '%s'.)r%)fact)rEr-r. exceptionRrz!_rewrite_gamma..exceptioncs8|s |}|dkr|S)z7 Test if arg is of form a*s+b, raise exception if not. r:) is_polynomialdegree all_coeffs)argr)rrrrGr-r. linear_arg]s   z"_rewrite_gamma..linear_argcsg|]}|fqSr-r-r)rrGr-r.r_srz Gammas partially over the strip.)Zevaluater<za is not an integerr): itertoolsrr`rr rTrrrrrrrrrrrrrr rdrWr7reas_independentrkZOnerrcrr%rrirZas_numer_denomZ make_argsr[ziprbis_Powrfbase is_IntegerrrrZLTZ all_rootsrZ NegativeOnerCr TypeErrorrangeHalfrhrr );rErGrrrr rTrZexp_rrrrrrrrrrZ s_multipliersgrro_rFZ s_multiplierfacexponentZnumerZdenomr7ZfacsZdfacsZ numer_gammasZ denom_gammasZ exponentialsZugammasZlgammasZufacsrrrrPrZrsrZgamma1Zgamma2Zfac_ZanapbmbqZgammasZplusZminusZnewaZnewckr-) rrrrrrrErrrrGr._rewrite_gammas^ 5H                $                       &        h     &&      rc shddlm}m}m}m}m} m} m} m} m } m }m }t dd|dd| |}| |||||fD]}|jrmfdd|jD}d d|D}d d|D}||}sa| ||| d }||t|fSzt|dd \}}}}}Wn tyYq2wz |||||}Wn tyYq2wr|}n>z||}Wn tytd |dw|jrt|jdkr| t||jdjd| t||jd jd}t| |j|j| kg}|ttt|jt|jkd| |jd kt| |j|j| kg7}t|}|dkr"td |d||||fStd |d)zs A helper for the real inverse_mellin_transform function, this one here assumes x to be real and positive. r) rrS hyperexpandmeijergrrrfactor Heavisider rRrzinverse-mellin-transformT)Zpositivec s g|] }t|ddqS)Fr{)_inverse_mellin_transform)rXG as_meijergrGstriprFr-r.r_s   z-_inverse_mellin_transform..cSg|]}|dqS)r:r-rXrr-r-r.r_rcSr)rr-rr-r-r.r_r)Zgensr:rzCould not calculate integralFzdoes not convergerM) r`rrSrrrrrrrr rRrZrewriterer7rdrrrr% ValueErrorrCrrirargumentZdeltarrrnu)rrGZx_rrrrSrrrrrrrr rRrrnrrmrrCerrhrPr-rr.rs`4 $    *  rNc@HeZdZdZdZedZedZddZe 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|SrA)r_none_sentinelr4__new__)clsrrGrFrroptsr-r-r.r 5s zInverseMellinTransform.__new__cCs:|jd|jd}}|tjurd}|tjurd}||fS)Nr)r7rr )r)rrr-r-r.fundamental_strip<s   z(InverseMellinTransform.fundamental_stripc Ksddlm}tdur4ddlm}m}m}m} m} m} m } m } m }m }m }m}|||| | | | | ||||h a||D]}|jrO||rO|jtvrOtd|d|q8|j}t||||fi|S)Nr)postorder_traversal) rr rrrrcoshsinhtanhcoth factorialrfrzComponent %s not recognised.)r`r_allowedrr rrrrrrrrrrZ is_FunctionrWrYr%rr)r)rrGrFrHrrr rrrrrrrrrrrErr-r-r.rIEs 8 z)InverseMellinTransform._compute_transformcCsNddlm}|jj}t||| |||t||tfdtjtjS)Nr)Ir<) r`rr,_crrr Pi ImaginaryUnit)r)rrGrFrrr-r-r.rLVs :z#InverseMellinTransform._as_integralN) r/r0r1r2rjrr rr rtrrIrLr-r-r-r.r's   rcKs$t||||d|djdi|S)aP 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.integrals.transforms import inverse_mellin_transform >>> from sympy import 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 rr:Nr-)rr\)rrGrFrrHr-r-r.inverse_mellin_transform\s$6rcsddlm}m}mddlmfddfddfdd fd d }d d }ddlm}||}|||}|||fdd}|||}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) r)StrictGreaterThanStrictLessThan Unequality)Abscs&|krdS|jr|jkr|jSdSNr:)rrr)ex)rGr-r.powers z_simplifyconds..powercs|r |r dSt|r|jd}t|r |jd}|r.d|d|S|}|dur8dSz,|dkrLt|t|kdkrLWdS|dkr_t|t|kdkrbWdSWdSWdStynYdSw)z_ Return True only if |ex1| > |ex2|, False only if |ex1| < |ex2|. Else return None. Nrr:TF)rWrfr7rr)Zex1Zex2r)rrbiggerr"rGr-r.r#s(        z_simplifyconds..biggercsH|jst|r|jst|s||kS||}|dur | S||kS)z simplify x < y N) is_positiverf)rFyr)rr#r-r.replies z_simplifyconds..repliecs(||}|dks |dkrdS||SNTFr-)rFr%r)rr#r-r.replues  z_simplifyconds..repluecWs"|dks|dkr t|S|j|Sr')boolr)r!r7r-r-r.repls z_simplifyconds..repl) collect_abscs ||SrAr-)rFr%)r&r-r.rs z _simplifyconds..) sympy.core.relationalrrrr`rZsympy.simplify.radsimpr+r )rxrGrrrr(r*r+r-)rrrr#r"r&rGr._simplifycondss      r-cCst||tS)zs Expand an expression involving DiractDelta to get it as a linear combination of DiracDelta functions. )r#rdrrxr-r-r.expand_dirac_deltasr/c stddlm mm}mmmmmm m m m }t d dgd}g}g}zt\} } Wn ty@tddw| D]4\} } | t|} | rb|| d| |qE| jddjrrtdd|| | qE|t| || g|Rdtf||}|tst| |t tjfS|jstdd |jd\}}|trtdd  f d d  fd dt |D}dd|D}|sdd|D}t!t"|}dd|j#fddd|s tdd|d\}} fdd}|r(t$| |}t$| |}t| |||t%||fS)z. The backend function for Laplace transforms. r) rrrrrperiodic_argumentrrrr polar_liftrRrGr)excludeLaplacez'could not expand DiracDelta expressionsznot implemented yet.rrc slt }tj}tt|} d gd\}}}}}}} |t |||k|t |||kt |||||kt |||||kt |||||kt |||||kf} |D]3} t} g} t| D]}|jr |jj vr|j }|jrt |t t fr|j}| D] }||rnqrȈ|jrȈ||dkrȈ | dk}|||t | |t ||dks||t || ||t ||dks)||t || ||t ||dkrEtfdd||||| fDrE |k}| dd  }|jri|jd vsi| si| so| |g7} qt| }|jr~|jd vr| |g7} q|j krtd d |j| } q| tkr| |}qut|t| }qu||jr|jfS|fS) z7 Turn ``conds`` into a strip and auxiliary conditions. zp q w1 w2 w3 w4 w5r r2r<rc3s|]}|jVqdSrA)r$)rXZwildrr-r.rZGsz<_laplace_transform..process_conds..cSs|dSr})rrrr-r-r.rJsz;_laplace_transform..process_conds..rr3zconvergence not in half-plane?)rr rrrrrrZrhsr>reversedrfrrZ reversedsignmatchr$allrrrrWrurr%rrZ canonical)rrrrrZw1Zw2Zw3Zw4Zw5patternsrrrrpatrr) rrrrarg_rrErr1rrGrrr5r.r"s     ":4"(       z)_laplace_transform..process_condscrr-r-rrr-r.r_`rz&_laplace_transform..cSs*g|]}|ddkr|dt kr|qS)r:Frrr]r-r-r.r_as*cSr)r:Fr-r]r-r-r.r_crcSs|dks|dkr dS|S)NTFrrr.r-r-r.cntfsz_laplace_transform..cntcs|d |dfSNrr:r-r)r<r-r.rjrz$_laplace_transform..rrcs |SrA)rr.)rGrr-r.sbsp z_laplace_transform..sbs)&r`rrrrrr0rrrrr1rRrr/r$r%itemsr7rrhrr7Zis_zerorrrWrryr rrrr[r rr-r)rErrrrrRrZ deltazeroZ deltanonzeroZ integratableZ deltadictZ dirac_funcZ dirac_coeffrrrPrZconds2rr>r-)rrrrr;r<rrErr1rrrGrrrr._laplace_transformsf8 *  $>     $rAc@r) LaplaceTransformz 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. r3cKrrA)rA)r)rErrGrHr-r-r.rIrz#LaplaceTransform._compute_transformcCs*ddlm}t||| ||dtfS)Nr)r)r`rrr)r)rErrGrr-r-r.rLs zLaplaceTransform._as_integralcCsbddlm}g}g}|D]\}}||||q t|}||}|dkr-tddd||fS)NrrFr3zNo combined convergence.)r`rrhrr%)r)rOrrZplanesplanerPr-r-r.rQs    z LaplaceTransform._collapse_extraNrr-r-r-r.rBxs   rBc  st|tr_t|dr_dd }|r*|r*tddddd|fd d Sfd d |D}|rSt|\}}} t|g|j |R} | t |t | fSt|g|j |RSt |j diS)ay 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 `a < \operatorname{Re}(s)`. This function returns ``(F, a, cond)`` where ``F`` is the Laplace transform of ``f``, `\operatorname{Re}(s) > a` is the half-plane of convergence, and ``cond`` are auxiliary convergence conditions. 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 as .. math :: F(s) = \lim_{\tau\to 0^{-}} \int_{\tau}^\infty e^{-st} f(t) \mathrm{d}t. If the integral cannot be 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.integrals import laplace_transform >>> from sympy.abc import t, s, a >>> from sympy.functions import DiracDelta, exp >>> 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) (-a/(a + s) + 1, 0, Abs(arg(a)) <= pi/2) See Also ======== inverse_laplace_transform, mellin_transform, fourier_transform hankel_transform, inverse_hankel_transform applyfuncr|Fz:laplace_transform of a Matrix with noconds=False (default)z7the option legacy_matrix=False to get the new behaviouriTz1.9)ZfeatureZ useinsteadZissueZdeprecated_since_versioncst|fiSrAlaplace_transform)fijrHrGrr-r.rrz#laplace_transform..cs g|] }t|fiqSr-rE)rXrGrHr-r.r_s z%laplace_transform..Nr-)rfr"hasattrgetr!warnrDrtypeshaperrrBr\) rErrGZ legacy_matrixrHrZelements_transelementsZavalsZ conditionsZ f_laplacer-rHr.rFs$9rFc sddlmmmmm}mm}ddlm }m t ddd  fdd}| r3| }|jrP| fd d |jD} t|  |dfSzt| d tfdd d \} } Wn tynd } Ynw| d ur|| } | d urtd| d| jr| jd\} } | |rtd| dntj} | |} | jr|  || fSt d tjf fdd } | | } fdd} | | } t|  || fS)z6 The backend function for inverse Laplace transforms. r)rrlogexpand_complexr PiecewiserR)meijerint_inversion_get_coeff_exprTrcst|dkr |S|djdj}|\}}|djd}|djd}dt||||dt||S)z3 Simplify a piecewise expression from hyperexpand. rr<rr:)rir7rr)r7rrorZe1Ze2)rrQrSrr-r.pw_simps z+_inverse_laplace_transform..pw_simpcsg|] }t|qSr-)_inverse_laplace_transform)rXX)rCrGrrr-r.r_sz._inverse_laplace_transform..NF)rVr|Inverse LaplacerMz(inversion integral of unrecognised form.ucsp| }|r||St|dk}|jkr+|j}||S|j}| |Sr})rrWrurr)rZH0rZrelr)rrrOrrXr-r.simp_heaviside$s     z2_inverse_laplace_transform..simp_heavisidecs |SrAr-)r)rrPr-r.simp_exp2r?z,_inverse_laplace_transform..simp_exp)r`rrrOrPrrQrRsympy.integrals.meijerintrRrSrZis_rational_functionZapartrer7ryrrrr%rrWr rrr) rrGZt_rCrrrRrRrTrErPrYrZr-) rrQrSrrPrOrCrGrrrXr.rUsN$         rUc@r)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. rWrrcKs(|durtj}tj|||||fi|SrA)r\r r4r )r rrGrFrCr r-r-r.r KszInverseLaplaceTransform.__new__cCs|jd}|tjur d}|SNr)r7r\r )r)rCr-r-r.fundamental_planePs  z)InverseLaplaceTransform.fundamental_planecKst||||jfi|SrA)rUr^)r)rrGrrHr-r-r.rIWsz*InverseLaplaceTransform._compute_transformcCsTddlm}m}|jj}t|||||||t||tfdtjtj S)Nr)rrr<) r`rrr,rrrr rr)r)rrGrrrrr-r-r.rLZs<z$InverseLaplaceTransform._as_integralN) r/r0r1r2rjrr rr rtr^rIrLr-r-r-r.r\=s   r\c sFt|trt|dr|fddSt|jdiS)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.integrals.transforms import inverse_laplace_transform >>> from sympy import 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 rDcst|fiSrA)inverse_laplace_transform)ZFijrHrCrGrr-r.rrz+inverse_laplace_transform..Nr-)rfr"rIrDr\r\)rrGrrCrHr-r`r.r_`s,r_csltdtgd\fddfddfdd fd d fd d |S) zEFast inverse Laplace transform of rational function including RootSumza, b, nr4csN|s|S|jr|S|jr|S|jr|St|tr%|StrA)rWreis_MulrrfrrCr)_ilt_add_ilt_mul_ilt_pow _ilt_rootsumrGr-r._ilts  z#_fast_inverse_laplace.._iltcs|jt|jSrA)rYmapr7rbrgr-r.rcsz'_fast_inverse_laplace.._ilt_addcs$|\}}|jr t||SrA)rrarC)rrorx)rgrGr-r.rds z'_fast_inverse_laplace.._ilt_mulcs|}|durM|||}}}|jr>|dkr>| dt|| || t| S|dkrMt|| |Str=)r7rrr rC)rr7Znmamr)rrrrGrr-r.res4z'_fast_inverse_laplace.._ilt_powcs,|jj}|jj\}t|jt|t|SrA)ZfunrxZ variablesrZpolyrr)rrxvariablerir-r.rfs z+_fast_inverse_laplace.._ilt_rootsum)rr)rrGrr-) rgrcrdrerfrrrrGrr._fast_inverse_laplaces  rlc Csddlm}m}t||||||||t tf} | ts*t| |tj fSt||t tf} | t ttj fvsA| trGt ||d| j sPt ||d| j d\} } | trbt ||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. rrrz$function not integrable on real axisrr)r`rrrrrWrryr rZNaNr%rr7) rErFrrrrNrrrrZ integral_frPr-r-r._fourier_transforms *     rnc@0eZdZdZddZddZddZdd Zd S) FourierTypeTransformz# Base class for Fourier transforms.cCtd|jNz,Class %s must implement a(self) but does notrCr,r8r-r-r.rzFourierTypeTransform.acCrqNz,Class %s must implement b(self) but does notrsr8r-r-r.rrtzFourierTypeTransform.bcKs&t||||||jjfi|SrA)rnrrr,rjr)rErFrrHr-r-r.rIs  z'FourierTypeTransform._compute_transformcCsJddlm}m}|}|}t||||||||t tfS)Nrrm)r`rrrrrr)r)rErFrrrrrr-r-r.rLs*z!FourierTypeTransform._as_integralNr/r0r1r2rrrIrLr-r-r-r.rps  rpc@$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. ZFouriercCdSr r-r8r-r-r.rrJzFourierTransform.acC dtjS)Nr rr8r-r-r.r zFourierTransform.bNr/r0r1r2rjrrr-r-r-r.ry   rycKr)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 Nr-)ryr\rErFrrHr-r-r.fourier_transform 'rc@rx)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 FouriercCrzr r-r8r-r-r.rBrJzInverseFourierTransform.acCr{Nr<r}r8r-r-r.rEr~zInverseFourierTransform.bNrr-r-r-r.r6rrcKr)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 Nr-)rr\rrrFrHr-r-r.inverse_fourier_transformIrr)rrsqrtrc Cst|||||||dtf}|tst||tjfS|js(t||d|j d\}} |tr:t||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) rrrWrryr rrr%r7) rErFrrrKrNrrrPr-r-r._sine_cosine_transformzs$    rc@ro) SineCosineTypeTransformzK Base class for sine and cosine transforms. Specify cls._kern. cCrqrrrsr8r-r-r.rrtzSineCosineTypeTransform.acCrqrursr8r-r-r.rrtzSineCosineTypeTransform.bcKs,t||||||jj|jjfi|SrA)rrrr,_kernrjrvr-r-r.rIs z*SineCosineTypeTransform._compute_transformcCs<|}|}|jj}t|||||||dtfSr})rrr,rrr)r)rErFrrrrr-r-r.rLs$z$SineCosineTypeTransform._as_integralNrwr-r-r-r.rs  rc@(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. ZSinecCtdttSrrrr8r-r-r.rrzSineTransform.acCrzr r-r8r-r-r.rrJzSineTransform.bN r/r0r1r2rjrrrrr-r-r-r.r   rcKr)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 Nr-)rr\rr-r-r.sine_transform$rc@r)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 SinecCrrrr8r-r-r.rrzInverseSineTransform.acCrzr r-r8r-r-r.rrJzInverseSineTransform.bNrr-r-r-r.rrrcKr)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 Nr-)rr\rr-r-r.inverse_sine_transforms%rc@r)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. ZCosinecCrrrr8r-r-r.r3rzCosineTransform.acCrzr r-r8r-r-r.r6rJzCosineTransform.bN r/r0r1r2rjrrrrr-r-r-r.r&rrcKr)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 Nr-)rr\rr-r-r.cosine_transform:rrc@r)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 CosinecCrrrr8r-r-r.rnrzInverseCosineTransform.acCrzr r-r8r-r-r.rqrJzInverseCosineTransform.bNrr-r-r-r.rarrcKr)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 Nr-)rr\rr-r-r.inverse_cosine_transformurrc Csddlm}t|||||||dtf}|ts$t||tjfS|j s-t ||d|j d\}}|tr?t ||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. rbesseljrr) r`rrrrWrryr rrr%r7) rErrrrNrrrrPr-r-r._hankel_transforms "    rc@s4eZdZdZddZddZddZedd Zd S) HankelTypeTransformz+ Base class for Hankel transforms. cKs$|j|j|j|j|jdfi|Sr])rIr(r;r=r7)r)rHr-r-r.r\szHankelTypeTransform.doitcKst|||||jfi|SrA)rrj)r)rErrrrHr-r-r.rIsz&HankelTypeTransform._compute_transformcCs.ddlm}t|||||||dtfS)Nrr)r`rrr)r)rErrrrr-r-r.rLs "z HankelTypeTransform._as_integralcCs||j|j|j|jdSr])rLr(r;r=r7r8r-r-r.rqs zHankelTypeTransform.as_integralN) r/r0r1r2r\rIrLrtrqr-r-r-r.rsrc@eZdZdZdZdS)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. ZHankelNr/r0r1r2rjr-r-r-r.r rcKt||||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 Nr-)rr\)rErrrrHr-r-r.hankel_transform.rc@r)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 HankelNrr-r-r-r.rrrcKr)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 Nr-)rr\)rrrrrHr-r-r.inverse_hankel_transformrr)F)TrA)kr2 functoolsrr`rrrrrrr Z sympy.corer Zsympy.core.compatibilityr r rar r,rrrZsympy.core.numbersrZsympy.core.symbolrZsympy.functionsrZ(sympy.functions.elementary.miscellaneousrZsympy.integralsrrr[rZsympy.logic.boolalgrrrrrZsympy.simplifyrZsympy.utilitiesr Zsympy.utilities.exceptionsr!Zsympy.matrices.matricesr"Zsympy.polys.matrices.linsolver#r$rCr%r4Zsympy.solvers.inequalitiesruryrZ_nocondsrrrrrrrrrrrrr-r/rArBrFrUr\r_rlrnrpryrrrrrrrrrrrrrrrrrrrrrrrr-r-r-r.s $            D"-.0 ;5=[ | "Q Q #11 *. '('+  1