B [8@sdZddlmZmZddlmZddlmZmZddl m Z ddl m Z ddl mZddlmZmZdd lmZdd lmZmZmZmZmZdd lmZdd lmZdd lmZGddde Z!Gddde Z"ddl#m$Z$ddZ%ddZ&e&dZ'ddZ(e'e(dfddZ)Gddde"Z*dd Z+d!d"Z,Gd#d$d$e-Z.d%d&Z/e&ddid'd(Z0d)a1Gd*d+d+e"Z2d,d-Z3d.d/Z4e'djd0d1Z5Gd2d3d3e"Z6d4d5Z7e&ddkd6d7Z8Gd8d9d9e"Z9dld:d;Z:e&ddmdd?d?e"ZGdDdEdEe<Z?dFdGZ@ddHlAmBZBmCZCmDZDmEZEe&ddndIdJZFGdKdLdLe"ZGGdMdNdNeGZHdOdPZIGdQdRdReGZJdSdTZKGdUdVdVeGZLdWdXZMGdYdZdZeGZNd[d\ZOe&ddod]d^ZPGd_d`d`e"ZQGdadbdbeQZRdcddZSGdedfdfeQZTdgdhZUd)S)pz Integral Transforms )print_functiondivision)S)reducerange)Function)oo)Dummy) integrateIntegral)_dummy)to_cnf conjuncts disjunctsOrAnd)simplify)default_sort_key) MatrixBasecs eZdZdZfddZZS)IntegralTransformErroray Exception raised in relation to problems computing transforms. 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. cs"tt|d||f||_dS)Nz'%s Transform could not be computed: %s.)superr__init__function)selfZ transformrmsg) __class__9lib/python3.7/site-packages/sympy/integrals/transforms.pyr"s zIntegralTransformError.__init__)__name__ __module__ __qualname____doc__r __classcell__rr)rrrs rc@steZdZdZeddZeddZeddZedd Zd d Z d d Z ddZ ddZ eddZ ddZdS)IntegralTransforma Base class for integral transforms. 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 IntegralTransformError. Also set cls._name. 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. r)args)rrrrr8szIntegralTransform.functioncCs |jdS)z; The dependent variable of the function to be transformed. )r$)rrrrfunction_variable=sz#IntegralTransform.function_variablecCs |jdS)z% The independent transform variable. )r$)rrrrtransform_variableBsz$IntegralTransform.transform_variablecCs|jj|jh|jhS)zj This method returns the symbols that will exist when the transform is evaluated. )r free_symbolsunionr(r&)rrrrr)GszIntegralTransform.free_symbolscKstdS)N)NotImplementedError)rfxshintsrrr_compute_transformPsz$IntegralTransform._compute_transformcCstdS)N)r+)rr,r-r.rrr _as_integralSszIntegralTransform._as_integralcCs$t|}|dkr t|jjdddS)NF)rrrname)rextracondrrr_collapse_extraVsz!IntegralTransform._collapse_extrac sddlm}m}m}ddlm}dd}tfddj |D }|r~yj jj j fSt k r|YnXj}|js||}|jrP|d<fdd |jD} g} g} xH| D]@} t| ts| g} | | dt| d kr| | d d g7} qW|| } | s| Sy| } t| gt| St k rNYnX|rht jjjd|j \} }| j||gtjd d S) a Try to evaluate the transform in closed form. 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|]}|jVqdS)N)hasr&).0func)rrr psz)IntegralTransform.doit..cs2g|]*}j|gtjddjfqS)r%N)rlistr$doit)r=r-)r/rrr sz*IntegralTransform.doit..r%N)sympyr7r8r9sympy.core.functionr:popanyratomsr0r&r(ris_Addr$ isinstancetupleappendlenr6r_name as_coeff_mulr@)rr/r7r8r9r:r;Z try_directlyfnresr4ressr-coeffrestr)r/rrrA[sN         zIntegralTransform.doitcCs||j|j|jS)N)r1rr&r()rrrr as_integrals zIntegralTransform.as_integralcGs|jS)N)rT)rr$rrr_eval_rewrite_as_Integralsz+IntegralTransform._eval_rewrite_as_IntegralN)rrr r!propertyrr&r(r)r0r1r6rArTrUrrrrr#(s    A r#)_solve_inequalitycCs,ddlm}m}|r(t|||ddS|S)Nr) powdenestpiecewise_foldT)Zpolar)rCrXrYr)exprrArXrYrrr _simplifysr[csfdd}|S)a5 This is a decorator generator for dropping convergence conditions. 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}|fdd}|S)Nr)wrapscs&|d}||}|r"|dS|S)Nnocondsr)rE)r$kwargsr]rP)defaultr>rrwrappers   z0_noconds_..make_wrapper..wrapper)Zsympy.core.decoratorsr\)r>r\r`)r_)r>r make_wrappers z_noconds_..make_wrapperr)r_rar)r_r _noconds_s rbFcCst||dtfS)Nr)r r)r,r-rrr_default_integratorsrcTc sddlmmmmtdd|||d||}|tsdt| ||t t ft j fS|j svtd|d|jd\}}|trtd|dfd d fd d t|D}d d |D}|jfddd|std|d|d\}} } t| |||| f| fS)z0 Backend function to compute Mellin transforms. r)reMaxMin count_opsr.zmellin-transformr%Mellinzcould not compute integralzintegral in unexpected formc sJt }t}tj}tt|}tddd}x|D] }t}t }g} xt|D]} | dd|} | j r| j dks| s| |s| | g7} qNt | |} | j r| j dkr| | g7} qN| j |kr܈| j|}qN| j |}qNW|tkr ||kr ||}q0|t kr.||kr.||}q0t|t| }q0W|||fS)zN Turn ``cond`` into a strip (a, b), and auxiliary conditions. tT)realcSs |dS)Nr) as_real_imag)r-rrrsz:_mellin_transform..process_conds..)z==z!=)rrtruerr r rreplacesubs is_Relationalrel_opr<rWltsgtsrr) r5abauxcondsrica_b_aux_dd_soln)rerfrdr.rr process_condss>          z(_mellin_transform..process_condscsg|] }|qSrr)r=rx)rrrrBsz%_mellin_transform..cSsg|]}|ddkr|qS)r'Fr)r=r-rrrrBscs|d|d|dfS)Nrr%r'r)r-)rgrrrlsz#_mellin_transform..)keyzno convergence found)rCrdrerfrgr r<r r[rorrrm is_Piecewiserr$rsort) r,r-s_Z integratorrFr5rwrtrurvr)rerfrgrrdr.r_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. rhcKst|||f|S)N)r)rr,r-r.r/rrrr0%sz"MellinTransform._compute_transformcCst|||d|dtfS)Nr%r)r r)rr,r-r.rrrr1(szMellinTransform._as_integralc Csddlm}m}g}g}g}x2|D]*\\}}} ||g7}||g7}|| g7}q"W||||ft|f} | dd| ddkdks| ddkrtddd| S)Nr)rerfr%TFrhzno combined convergence.)rCrerfrr) rr4rerfrtrur5ZsaZsbrxrPrrrr6+s  ( zMellinTransform._collapse_extraN)rrr r!rMr0r1r6rrrrrs rcKst|||jf|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`. 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)``). >>> 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 )rrA)r,r-r.r/rrrmellin_transform;s$rc Csddlm}m}m}m}|\}} |||}|| |} || || d} |||| | |d| | ||d| |fS)as 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)``. >>> 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(-s + 1), pi) >>> _rewrite_sin((pi, 0), s, 1, 0) (gamma(s - 1), gamma(-s + 2), -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(-s + 3/2), -pi) >>> _rewrite_sin((pi, pi), s, 0, 1) (gamma(s), gamma(-s + 1), -pi) >>> _rewrite_sin((2*pi, 0), s, 0, S(1)/2) (gamma(2*s), gamma(-2*s + 1), pi) >>> _rewrite_sin((2*pi, 0), s, S(1)/2, 1) (gamma(2*s - 1), gamma(-2*s + 2), -pi) r)r8piceilinggammar%)rCr8rrrrk) Zm_nr.rtrur8rrrmnrrrr _rewrite_sinbs "  rc@seZdZdZdS)MellinTransformStripErrorzF Exception raised by _rewrite_gamma. Mainly for internal use. N)rrr r!rrrrrsrc<sddlm}ddlmm}m}m m}m}m m } m } m } m } m} m}m}m}m}t||g\ fdd}g}xT|D]F}| sq|jd}|jr| d}| \}}||g7}qWx`| | ||D]L}| sq|jd}|jr| d}| \}}||| g7}qWdd|D}tdx|D]}|jsN|PqNWfd d|D}td d |Dsjstd d dt| dd|Dtd}|krt|dkr܈}nt|dd|D}td}td} |||}d|}d k r6|9d k rH|9!\}}|"|}|"|}t#t$||dt#t$||d}g}g} g}!g}"g}#fddx |r|%\r|!|"}$}%|| }&}'n|"|!}$}%| |}&}' fdd}( s|&g7}&qj&s2t'|rj&rHj(})j}*n|d})jd}*|*j)r}+|*dkrv|+ }+||)|+fgt*|*7}qnL|) s|(|*\}}sd|)})|#|)|g7}#||)|g7}nq+ r },|,,dkr^|,-d}| |, }-t|-|,,kr8|.|,}-|&|g7}&| fdd|-D7}q|,/\}}.|&|g7}&|.| }.||.r|$td|. dfg7}$|%td|. fg7}%n2|&dg7}&|$td|.dfg7}$|%td|.fg7}%qt'|rl|(jd\}}rZ|dkr2|| |dksR|dkrZ|| |dkrZt0d|$||fg7}$qt'| rjd}r||| |d|| | }/}0}1nt1|(| \}/}0}1||/ f|0 fg7}|&|1g7}&nt'|r0jd}|| |ddf| | d|dd fg7}nt'| rfjd}|| | d|ddfg7}nNt'|rjd}|| | d|ddf| |dd fg7}nqW||||| 9}ggggf\}2}3}4}5xX|!|2|4df|"|5|3dfgD]:\}6}7}8x(|6r6|6%\}}.|dkr|dkrt*t|},||,}9|.|,}:|j)sbt2dx(t3|,D]};|6|9|:|;|,fg7}6qlWr|d| d|,d|,|.tdd9}|#|,|g7}#n<|d| d|,d|,|.tdd}|#|,| g7}#q|dkr(|74d|.n |84|.qWqW||#}|2j5t6d|3j5t6d|4j5t6d|5j5t6d|2|3f|4|5f|||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. 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. >>> 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)Polyrr9rdCRootOfexpexpandrootsilcmrsincostancotigcd exp_polarcs|}dkr tkr dSdkr0|kSdkr@|kS|kdkrPdS|kdkr`dS|rhdSjszjsz|jr~dStddS)zU Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)rr)r)rxis_numer)ryrzrrdrrlefts    z_rewrite_gamma..leftr%cSsg|]}|jrt|n|qSr)is_realabs)r=r-rrrrBsz"_rewrite_gamma..csg|] }|qSrr)r=r-)common_coefficientrrrBscss|]}|j VqdS)N) is_Rational)r=r-rrrr?sz!_rewrite_gamma..ZGammaNzNonrational multipliercSsg|]}t|jqSr)rq)r=r-rrrrBscSsg|]}t|jqSr)rp)r=r-rrrrBsTFcstdd|S)NzInverse MellinzUnrecognised form '%s'.)r)fact)r,rr exception(sz!_rewrite_gamma..exceptioncs8|s|}|dkr0|S)z7 Test if arg is of form a*s+b, raise exception if not. r%) is_polynomialdegree all_coeffs)argr)rrrr.rr linear_arg3s    z"_rewrite_gamma..linear_argcsg|]}|fqSrr)r=rx)rr.rrrBasrz Gammas partially over the strip.)Zevaluater'za is not an integer)r)7 itertoolsrrCrrr9rdrrrrrrrrrrrrrrGr<r$rHZas_independentrNrrFrrrrLroZas_numer_denomZ make_argsr@ziprEis_PowrIbaseZ is_IntegerrrrZLTZ all_rootsrr+r TypeErrorrrKrr).cSsg|] }|dqS)r%r)r=rrrrrBscSsg|] }|dqS)rr)r=rrrrrBs)Zgensr%zInverse MellinzCould not calculate integralNFzdoes not converger2)rCrr8rrrrrdrrrr7r ZrewriterHr$rGrorrrr+rrLrargumentZdeltarrrnu)rr.Zx_rrrr8rrrrrdrrrr7rrQrwrPrtruCerrhZdetailr5r)rr.rr-rrsJ4   $ "*  rNc@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. zInverse MellinNonerxcKs4|dkrtj}|dkrtj}tj||||||f|S)N)r_none_sentinelr#__new__)clsrr.r-rtruoptsrrrrs zInverseMellinTransform.__new__cCs:|jd|jd}}|tjkr$d}|tjkr2d}||fS)Nr)r$rr)rrtrurrrfundamental_strips   z(InverseMellinTransform.fundamental_stripc Ksddlm}tdkrlddlm}m}m}m} m} m} m } m } m }m }m }m}t|||| | | | | ||||g ax:||D].}|jrv||rv|jtkrvtd|d|qvW|j}t||||f|S)Nr)postorder_traversal) rrrrrrcoshsinhtanhcoth factorialrfzInverse MellinzComponent %s not recognised.)rCr_allowedrrrrrrrrrrrrsetZ is_Functionr<r>rrr)rrr.r-r/rrrrrrrrrrrrrr,rrrrr0s 8 z)InverseMellinTransform._compute_transformcCsNddlm}|jj}t||| |||t||tfdtjtjS)Nr)Ir') rCrr_cr rrPi ImaginaryUnit)rrr.r-rrxrrrr1)s z#InverseMellinTransform._as_integralN) rrr r!rMr rrrrVrr0r1rrrrrs rcKs t||||d|djf|S)a Compute the inverse Mellin transform of `F(s)` over the fundamental strip given by ``strip=(a, b)``. 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`. >>> 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/2 - 1/(2*x))*Heaviside(x - 1) >>> inverse_mellin_transform(f, s, x, (-1, 1)) -x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x) >>> inverse_mellin_transform(f, s, x, (1, oo)) (-x/2 + 1/(2*x))*Heaviside(-x + 1) See Also ======== mellin_transform hankel_transform, inverse_hankel_transform rr%)rrA)rr.r-rr/rrrinverse_mellin_transform/s0rcsddlm}m}mddlmfddfddfdd fd d }d d }|||}|||fdd}|||}t|S)a Naively simplify some conditions occurring in ``expr``, given that `\operatorname{Re}(s) > a`. >>> 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&|kr dS|jr"|jkr"|jSdS)Nr%)rrr)ex)r.rrpowers z_simplifyconds..powercs|r|rdSt|r,|jd}t|r@|jd}|r\d|d|S|}|dkrpdSyL|dkrt|t|kdkrdS|dkrt|t|kdkrdSWntk rYnXdS)z_ Return True only if |ex1| > |ex2|, False only if |ex1| < |ex2|. Else return None. Nrr%TF)r<rIr$rr)Zex1Zex2r)rrtbiggerrr.rrrs$       z_simplifyconds..biggercsH|jst|r |js(t|s(||kS||}|dk r@| S||kS)z simplify x < y N) is_positiverI)r-yr)rrrrreplies z_simplifyconds..repliecs(||}|dks|dkrdS||S)NTFr)r-rru)rrrrreplues z_simplifyconds..repluecWs"|dks|dkrt|S|j|S)NTF)boolrn)rr$rrrreplsz_simplifyconds..replcs ||S)Nr)r-r)rrrrlsz _simplifyconds..)Zsympy.core.relationalrrrrCrr)rZr.rtrrrrr)rrrtrrrr.r_simplifycondsfs     rc sddlm mm}mmmmmm m m t d t | dtf}|tst| |t tjfS|jstdd|jd\}}|trtdd f dd fd d t|D}d d |D}|sd d |D}|}d d|jfddd|sDtdd|d\} } fdd} |r|t| | }t| | } t| || | | | fS)z. The backend function for Laplace transforms. r) rdrerrrfperiodic_argumentrrWildsymbols polar_liftr.Laplacezcould not compute integralzintegral in unexpected formc spt }tj}tt|}tddd} d gd\}}}}}} } |t |||k|t |||kt |||||kt |||||kt |||||kt |||||kf} xr|D]h} t} g}x4t| D]&}|jr6 |j j kr6|j }x | D]}| |r.process_conds..cSs|dS)Nr)rrk)r-rrrrlsz;_laplace_transform..process_conds..)z==z!=rzconvergence not in half-plane?)rrrmrr r rrrpZrhsr)reversedmatchrallrnrorqr<rWrrrrr)rwrtrvrrrZw1Zw2Zw3Zw4Zw5Zpatternsrxryr{r|Zpatr}r~) rerfrrarg_rr,rrrdr.rri)rrrsn   $  &:8 (        z)_laplace_transform..process_condscsg|] }|qSrr)r=rx)rrrrBsz&_laplace_transform..cSs*g|]"}|ddkr|dt kr|qS)r%Fr)r)r=r-rrrrBscSsg|]}|ddkr|qS)r%Fr)r=r-rrrrBscSs|dks|dkrdS|S)NTFr)rg)rZrrrcntsz_laplace_transform..cntcs|d |dfS)Nrr%r)r-)rrrrlsz$_laplace_transform..)rzno convergence foundcs |S)N)ro)rZ)r.rrrsbssz_laplace_transform..sbs)rCrdrerrrfrrrrrrr r rr<r r[rorrmrrr$rrr) r,rirrrrr5rwZconds2rtrvrr)rerfrrrrrr,rrrrdr.rrrir_laplace_transforms84    $=    rc@s,eZdZdZdZddZddZddZd S) 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. rcKst|||f|S)N)r)rr,rir.r/rrrr02sz#LaplaceTransform._compute_transformcCs*ddlm}t||| ||dtfS)Nr)r)rCrr r)rr,rir.rrrrr15s zLaplaceTransform._as_integralcCsfddlm}g}g}x$|D]\}}||||qWt|}||}|dkr^tddd||fS)Nr)reFrzNo combined convergence.)rCrerKrr)rr4rerwZplanesplaner5rrrr69s   z LaplaceTransform._collapse_extraN)rrr r!rMr0r1r6rrrrr&s rc s>t|tr*t|dr*|fddSt|jfS)ab Compute the Laplace Transform `F(s)` of `f(t)`, .. math :: F(s) = \int_0^\infty e^{-st} f(t) \mathrm{d}t. 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. 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``). >>> from sympy.integrals import laplace_transform >>> from sympy.abc import t, s, a >>> laplace_transform(t**a, t, s) (s**(-a)*gamma(a + 1)/s, 0, -re(a) < 1) See Also ======== inverse_laplace_transform, mellin_transform, fourier_transform hankel_transform, inverse_hankel_transform applyfunccst|fS)N)laplace_transform)Zfij)r/r.rirrrlhsz#laplace_transform..)rIrhasattrrrrA)r,rir.r/r)r/r.rirrHsrc sdddlmmmmm}mddlm}m t dddfdd}y&t || d t fdd d \}} Wnt k rd }YnX|d kr|||}|d krt d |d |jr|jd\}} ||rt d |dntj} ||}|jr ||| fSt dfdd} || }fdd} || }t|||| fS)z6 The backend function for inverse Laplace transforms. r)rrlogexpand_complexr Piecewise)meijerint_inversion_get_coeff_expriT)rjcst|dkr|S|djdj}|\}}|djd}|djd}dt||||dt||S)z3 Simplify a piecewise expression from hyperexpand. rr'rr%)rLr$rr)r$rrRrZe1Ze2)rrrrirrpw_simpws z+_inverse_laplace_transform..pw_simpNF)r;r]zInverse Laplacer2z(inversion integral of unrecognised form.rcsn| }|r$|St|dk}|jkrR|j}|S|j}| SdS)Nr)ror<rWrrrs)rrtZrelr)rrrrirrrsimp_heavisides     z2_inverse_laplace_transform..simp_heavisidecs |S)Nr)r)rrrrsimp_expsz,_inverse_laplace_transform..simp_exp)rCrrrrr rsympy.integrals.meijerintrrr rrrrr$r<rrmrnror[) rr.Zt_rrr rrr,r5rrr)rrrrrrrirr_inverse_laplace_transformls8          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. zInverse LaplacerrxcKs$|dkrtj}tj|||||f|S)N)rrr#r)rrr.r-rrrrrrszInverseLaplaceTransform.__new__cCs|jd}|tjkrd}|S)Nr)r$rr)rrrrrfundamental_planes  z)InverseLaplaceTransform.fundamental_planecKst||||jf|S)N)rr )rrr.rir/rrrr0sz*InverseLaplaceTransform._compute_transformcCsTddlm}m}|jj}t|||||||t||tfdtjtj S)Nr)rrr') rCrrrrr rrrr)rrr.rirrrxrrrr1sz$InverseLaplaceTransform._as_integralN) rrr r!rMr rrrrVr r0r1rrrrrs rc sBt|tr,t|dr,|fddSt|jfS)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`. 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`. >>> 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 hankel_transform, inverse_hankel_transform rcst|fS)N)inverse_laplace_transform)ZFij)r/rr.rirrrlsz+inverse_laplace_transform..)rIrrrrrA)rr.rirr/r)r/rr.rirr s&r c Csddlm}m}t||||||||t tf} | tsTt| |tj fSt||t tf} | t ttj fks| trt ||d| j st ||d| j d\} } | trt ||dt| || fS)z Compute a general Fourier-type transform F(k) = a int_-oo^oo exp(b*I*x*k) f(x) dx. For suitable choice of a and b, this reduces to the standard Fourier and inverse Fourier transforms. r)rrz$function not integrable on real axiszcould not compute integralzintegral in unexpected form)rCrrr rr<r r[rrmZNaNrrr$) r,r-rrtrur3rrrrZ integral_fr5rrr_fourier_transforms *     r c@s0eZdZdZddZddZddZdd Zd S) FourierTypeTransformz# Base class for Fourier transforms.cCstd|jdS)Nz,Class %s must implement a(self) but does not)r+r)rrrrrt%szFourierTypeTransform.acCstd|jdS)Nz,Class %s must implement b(self) but does not)r+r)rrrrru)szFourierTypeTransform.bcKs"t||||||jjf|S)N)r rtrurrM)rr,r-rr/rrrr0-s z'FourierTypeTransform._compute_transformcCsJddlm}m}|}|}t||||||||t tfS)Nr)rr)rCrrrtrur r)rr,r-rrrrtrurrrr12sz!FourierTypeTransform._as_integralN)rrr r!rtrur0r1rrrrr "s r c@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. ZFouriercCsdS)Nr%r)rrrrrtEszFourierTransform.acCs dtjS)N)rr)rrrrruHszFourierTransform.bN)rrr r!rMrtrurrrrr 9sr cKst|||jf|S)aT 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. 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``. >>> 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 rA)r,r-rr/rrrfourier_transformLs!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 FouriercCsdS)Nr%r)rrrrrt|szInverseFourierTransform.acCs dtjS)Nr')rr)rrrrruszInverseFourierTransform.bN)rrr r!rMrtrurrrrrpsrcKst|||jf|S)az 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. 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``. >>> 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 )rrA)rrr-r/rrrinverse_fourier_transforms!r)rrsqrtrc Cst|||||||dtf}|ts>t||tjfS|jsPt||d|j d\}} |trtt||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. rzcould not compute integralzintegral in unexpected form) r rr<r r[rrmrrr$) r,r-rrtruKr3rrr5rrr_sine_cosine_transforms $    rc@s0eZdZdZddZddZddZdd Zd S) SineCosineTypeTransformzK Base class for sine and cosine transforms. Specify cls._kern. cCstd|jdS)Nz,Class %s must implement a(self) but does not)r+r)rrrrrtszSineCosineTypeTransform.acCstd|jdS)Nz,Class %s must implement b(self) but does not)r+r)rrrrruszSineCosineTypeTransform.bcKs(t||||||jj|jjf|S)N)rrtrur_kernrM)rr,r-rr/rrrr0s z*SineCosineTypeTransform._compute_transformcCs<|}|}|jj}t|||||||dtfS)Nr)rtrurrr r)rr,r-rrtrurrrrr1sz$SineCosineTypeTransform._as_integralN)rrr r!rtrur0r1rrrrrs 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. ZSinecCstdttS)Nr')rr)rrrrrtszSineTransform.acCsdS)Nr%r)rrrrruszSineTransform.bN) rrr r!rMrrrtrurrrrrs rcKst|||jf|S)a Compute the unitary, ordinary-frequency sine transform of `f`, defined as .. math:: F(k) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty f(x) \sin(2\pi x k) \mathrm{d} x. 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``. >>> 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**(-a + 1/2)*k**(a - 1)*gamma(-a/2 + 1)/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 )rrA)r,r-rr/rrrsine_transformsrc@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 SinecCstdttS)Nr')rr)rrrrrt%szInverseSineTransform.acCsdS)Nr%r)rrrrru(szInverseSineTransform.bN) rrr r!rMrrrtrurrrrrs rcKst|||jf|S)a5 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. 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``. >>> from sympy import inverse_sine_transform, exp, sqrt, gamma, pi >>> 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 )rrA)rrr-r/rrrinverse_sine_transform,src@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. ZCosinecCstdttS)Nr')rr)rrrrrt[szCosineTransform.acCsdS)Nr%r)rrrrru^szCosineTransform.bN) rrr r!rMrrrtrurrrrrNs rcKst|||jf|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. 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``. >>> 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 )rrA)r,r-rr/rrrcosine_transformbsrc@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 CosinecCstdttS)Nr')rr)rrrrrtszInverseCosineTransform.acCsdS)Nr%r)rrrrruszInverseCosineTransform.bN) rrr r!rMrrrtrurrrrrs rcKst|||jf|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. 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``. >>> from sympy import inverse_cosine_transform, exp, 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 )rrA)rrr-r/rrrinverse_cosine_transformsrc Csddlm}t|||||||dtf}|tsHt||tjfS|j sZt ||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. r)besseljzcould not compute integralzintegral in unexpected form) rCrr rr<r r[rrmrrr$) r,rrrr3rrrr5rrr_hankel_transforms "    r c@s4eZdZdZddZddZddZedd Zd S) HankelTypeTransformz+ Base class for Hankel transforms. cKs |j|j|j|j|jdf|S)Nr)r0rr&r(r$)rr/rrrrAs  zHankelTypeTransform.doitcKst|||||jf|S)N)r rM)rr,rrrr/rrrr0sz&HankelTypeTransform._compute_transformcCs.ddlm}t|||||||dtfS)Nr)r)rCrr r)rr,rrrrrrrr1s z HankelTypeTransform._as_integralcCs||j|j|j|jdS)Nr)r1rr&r(r$)rrrrrTszHankelTypeTransform.as_integralN) rrr r!rAr0r1rVrTrrrrr!s r!c@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. ZHankelN)rrr r!rMrrrrr"sr"cKst||||jf|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. 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``. >>> from sympy import hankel_transform, inverse_hankel_transform >>> from sympy import gamma, exp, sinh, cosh >>> from sympy.abc import r, k, m, nu, a >>> ht = hankel_transform(1/r**m, r, k, nu) >>> ht 2*2**(-m)*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/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"rA)r,rrrr/rrrhankel_transforms(r#c@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 HankelN)rrr r!rMrrrrr$&sr$cKst||||jf|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. 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``. >>> from sympy import hankel_transform, inverse_hankel_transform, gamma >>> from sympy import gamma, exp, sinh, cosh >>> from sympy.abc import r, k, m, nu, a >>> ht = hankel_transform(1/r**m, r, k, nu) >>> ht 2*2**(-m)*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/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$rA)rrrrr/rrrinverse_hankel_transform3s(r%)F)T)T)N)T)T)T)Vr!Z __future__rrZ sympy.corerZsympy.core.compatibilityrrrDrZsympy.core.numbersrZsympy.core.symbolr Zsympy.integralsr r rr Zsympy.logic.boolalgr rrrrZsympy.simplifyrZsympy.utilitiesrZsympy.matrices.matricesrr+rr#Zsympy.solvers.inequalitiesrWr[rbZ_nocondsrcrrrr ValueErrorrrrrrrrrrrrrr r r r rrrrCrrrrrrrrrrrrrrr r!r"r#r$r%rrrrs        | D"'+, 857W h"$ F# / $( !"!%  +