ó ¡¼™\c@ s*dZddlmZmZddlmZddlmZmZm Z ddl m Z ddl m Z mZmZddlmZddlmZdd lmZmZdd lmZdd lmZmZmZmZmZdd lm Z dd l!m"Z"ddl#m$Z$de%fd„ƒYZ&de fd„ƒYZ'ddl(m)Z)d„Z*d„Z+e+e,ƒZ-d„Z.e-e.e/d„ƒZ0de'fd„ƒYZ1d„Z2d„Z3de4fd„ƒYZ5d„Z6e+e/ƒe,d„ƒZ7e8a9d e'fd!„ƒYZ:d"„Z;d#„Z<e-e/d$„ƒZ=d%e'fd&„ƒYZ>d'„Z?e+e/ƒe/d(„ƒZ@d)e'fd*„ƒYZAe8d+„ZBe+e/ƒe/d,„ƒZCd-e'fd.„ƒYZDd/eDfd0„ƒYZEd1„ZFd2eDfd3„ƒYZGd4„ZHdd5lImJZJmKZKmLZLmMZMe+e/ƒe/d6„ƒZNd7e'fd8„ƒYZOd9eOfd:„ƒYZPd;„ZQd<eOfd=„ƒYZRd>„ZSd?eOfd@„ƒYZTdA„ZUdBeOfdC„ƒYZVdD„ZWe+e/ƒe/dE„ƒZXdFe'fdG„ƒYZYdHeYfdI„ƒYZZdJ„Z[dKeYfdL„ƒYZ\dM„Z]dNS(Os Integral Transforms iÿÿÿÿ(tprint_functiontdivision(tS(treducetrangetiterable(tFunction(t _canonicaltGetGt(too(tDummy(t integratetIntegral(t_dummy(tto_cnft conjunctst disjunctstOrtAnd(tsimplify(tdefault_sort_key(t MatrixBasetIntegralTransformErrorcB seZdZd„ZRS(sy 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. cC s-tt|ƒjd||fƒ||_dS(Ns'%s Transform could not be computed: %s.(tsuperRt__init__tfunction(tselft transformRtmsg((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR#s(t__name__t __module__t__doc__R(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRs tIntegralTransformcB s†eZdZed„ƒZed„ƒZed„ƒZed„ƒZd„Zd„Z d„Z d„Z ed „ƒZ d „Z RS( sÞ 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. cC s |jdS(s! The function to be transformed. i(targs(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR9scC s |jdS(s; The dependent variable of the function to be transformed. i(R"(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytfunction_variable>scC s |jdS(s% The independent transform variable. i(R"(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyttransform_variableCscC s#|jjj|jhƒ|jhS(sj This method returns the symbols that will exist when the transform is evaluated. (Rt free_symbolstunionR$R#(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR%HscK s t‚dS(N(tNotImplementedError(Rtftxtsthints((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_compute_transformQscC s t‚dS(N(R'(RR(R)R*((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt _as_integralTscC s7t|Œ}|tkr3t|jjddƒ‚n|S(Nt(RtFalseRt __class__tnametNone(Rtextratcond((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_collapse_extraWs  c s†ddlm}m}m}ddlm}|jdtƒ}t‡fd†ˆj j |ƒDƒƒ }|r§y#ˆj ˆj ˆj ˆj |SWq§tk r£q§Xnˆj }|jsÈ||ƒ}n|jr||drsiii(tsympyR6R7R8tsympy.core.functionR9tpopR/tanyRtatomsR,R#R$Rtis_AddR"R0tlisttdoitt isinstancettupletappendtlenR5Rt_namet as_coeff_mul(RR+R6R7R8R9R:t try_directlytfnR)tresR3tresstcoefftrest((Rs9lib/python2.7/site-packages/sympy/integrals/transforms.pyRE]sV      ?     cC s|j|j|j|jƒS(N(R-RR#R$(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt as_integral¥scO s|jS(N(RR(RR"tkwargs((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_eval_rewrite_as_Integralªs(RRR tpropertyRR#R$R%R,R-R5RERRRT(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR!)s    H(t_solve_inequalitycC s<ddlm}m}|r8t|||ƒdtƒƒS|S(Niÿÿÿÿ(t powdenesttpiecewise_foldtpolar(R>RWRXRtTrue(texprRERWRX((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt _simplify°sc s‡fd†}|S(s5 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). c s2ddlm}|ˆƒ‡‡fd†ƒ}|S(Niÿÿÿÿ(twrapsc s3|jdˆƒ}ˆ||Ž}|r/|dS|S(Ntnocondsi(R@(R"RSR^RN(tdefaultR=(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytwrapperÉs (tsympy.core.decoratorsR](R=R]R`(R_(R=s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt make_wrapperÆs((R_Rb((R_s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt _noconds_·s cC st||dtfƒS(Ni(R R (R(R)((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_default_integratorÙsc  s´ddlm‰m‰m‰m‰tdd|ƒ‰||ˆd||ƒ}|jtƒsŠt|j ˆ|ƒ|ƒt t ft j fS|j s¨td|dƒ‚n|jd\}}|jtƒrßtd|d ƒ‚n‡‡‡‡fd †}gt|ƒD]}||ƒ^q} g| D]}|d tkr#|^q#} | jd ‡fd †ƒ| sytd|dƒ‚n| d\} } } t|j ˆ|ƒ|ƒ| | f| fS(s0 Backend function to compute Mellin transforms. iÿÿÿÿ(tretMaxtMint count_opsR*smellin-transformitMellinscould not compute integralisintegral in unexpected formc  sÏt }t}tj}tt|ƒƒ}tddtƒ}x…|D]}}t}t }g} x÷t|ƒD]é} | jˆd„ƒj ˆˆƒ|ƒ} | j sÌ| j dksÌ| j ˆƒsÌ| j |ƒ rß| | g7} qgnt | |ƒ} | j s| j dkr| | g7} qgn| j|kr>ˆ| j|ƒ}qgˆ| j|ƒ}qgW|tkr~||kr~ˆ||ƒ}qA|t kr©||kr©ˆ||ƒ}qAt|t| Œƒ}qAW|||fS(sN Turn ``cond`` into a strip (a, b), and auxiliary conditions. tttrealcS s|jƒdS(Ni(t as_real_imag(R)((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytR.s==s!=(s==s!=(s==s!=(R RttrueRRR RZRtreplacetsubst is_Relationaltrel_opR;RVtltstgtsRR( R4tatbtauxtcondsRjtcta_tb_taux_tdtd_tsoln(RfRgReR*(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt process_condsñs>  !    itkeyc s |d|dˆ|dƒfS(Niii((R)(Rh(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRmR.sno convergence found(R>ReRfRgRhRR;R R\RpR RRnt is_PiecewiseRR"RR/tsort( R(R)ts_t integratorRtFR4R€RyRxRuRvRw((RfRgRhReR*s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_mellin_transformÝs&", &%)tMellinTransformcB s/eZdZdZd„Zd„Zd„ZRS(sâ 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. RicK st||||S(N(R‡(RR(R)R*R+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,.scC s"t|||d|dtfƒS(Nii(R R (RR(R)R*((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-1sc C sÛddlm}m}g}g}g}xA|D]9\\}}} ||g7}||g7}|| g7}q/W||Œ||Œft|Œf} | dd| ddktksÂ| dtkr×tdddƒ‚n| S(Niÿÿÿÿ(RfRgiiRisno combined convergence.(R>RfRgRRZR/RR2( RR3RfRgRuRvR4tsatsbRyRN((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR54s  $2(RRR RJR,R-R5(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRˆ"s   cK st|||ƒj|S(s  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 (RˆRE(R(R)R*R+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytmellin_transformDs$c C sªddlm}m}m}m}|\}} |||ƒ}|| |ƒ} || || jƒdƒ} |||| | ƒ|d| | ||ƒd| |fS(sm 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(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) iÿÿÿÿ(R7tpitceilingtgammaii(R>R7RŒRRŽRl( tm_nR*RuRvR7RŒRRŽtmtntr((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt _rewrite_sinks "" tMellinTransformStripErrorcB seZdZRS(sF Exception raised by _rewrite_gamma. Mainly for internal use. (RRR (((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR”–sc> s… ddlm}ddlm‰m}m}m‰m}m}m ‰m } m } m } m } m} m}m}m}m}t||gƒ\‰‰‡‡‡‡fd†}g}xzˆj|ƒD]i}|jˆƒsÛqÀn|jd}|jr|jˆƒd}n|jˆƒ\}}||g7}qÀWx‡ˆj| | ||ƒD]m}|jˆƒsaqFn|jd}|jr|jˆƒd}n|jˆƒ\}}||| g7}qFWg|D]!}|jrÙt|ƒn|^q¾}tdƒ}x!|D]}|jsø|}PqøqøWg|D]}||^q}td„|DƒƒsR|j rgtddd ƒ‚n|t | g|D]}t|j!ƒ^qwtdƒƒ}||krøt"|ƒdkrÆ|}qø|t |g|D]}t|j#ƒ^qÖƒ}nˆj$ˆˆ|ƒ‰tdƒ|}tdƒ|}ˆdk rGˆ|9‰nˆdk r`ˆ|9‰nˆj%ƒ\}}|j&|ƒ}|j&|ƒ}t't(||t)ƒƒƒt't(||t*ƒƒƒ}g} g}!g}"g}#g}$‡fd †‰xK|r> |j+ƒ\‰}%|%r/|"|#}&}'| |!}(})n|#|"}&}'|!| }(})‡‡‡‡fd †}*ˆjˆƒs€|(ˆg7}(qôˆj,s˜t-ˆ|ƒrˆj,r¶ˆj.}+ˆj},n|dƒ}+ˆjd},|,j/r|%}-|,dkrô|- }-n||+|-fgt|,ƒ7}qôq; |+jˆƒsp|*|,ƒ\}}|%sKd|+}+n|$|+|g7}$| |+|g7} q; ˆˆƒ‚qôˆj0ˆƒr숈ˆƒ}.|.j1ƒdkr2|.j2ƒd}| |.ˆƒ}/t"|/ƒ|.j1ƒkrø|j3|.ƒ}/n|(|g7}(|g|/D]}0ˆ|0|%f^q7}qôn|.j4ƒ\}}0|(|g7}(|0| }0||0|%ƒr¦|&tdƒ|0 dfg7}&|'tdƒ|0 fg7}'q; |(dg7}(|&tdƒ|0dfg7}&|'tdƒ|0fg7}'qôt-ˆ|ƒrŽ|*ˆjdƒ\}}|%rx|dkr@|| ||%ƒt*ksf|dkrx|| ||%ƒt)krxt5d ƒ‚qxn|&||fg7}&qôt-ˆ| ƒr1ˆjd}|%rß||| ƒ|d|| ƒ| }1}2}3n$t6|*|ƒˆˆˆƒ\}1}2}3||1|% f|2|% fg7}|(|3g7}(qôt-ˆ|ƒrˆjd}|| |d t*ƒ|%f| | d|d t*ƒ|% fg7}qôt-ˆ| ƒrÓˆjd}|| | d|d t*ƒ|%fg7}qôt-ˆ|ƒr/ ˆjd}|| | d|d t*ƒ|%f| |d t*ƒ|% fg7}qôˆˆƒ‚qôW||| Œ||!Œ9}ggggf\}4}5}6}7x |"|4|6t)f|#|7|5t*fgD]z\}8}9}:}%xe|8r |8j+ƒ\}}0|dkrä |d krä tt|ƒƒ}.||.};|0|.}<|j/s t7dƒ‚nx/t8|.ƒD]!}=|8|;|<|=|.fg7}8q- W|%rœ |d| d|.d|.|0tdƒd9}|$|.|g7}$q± |d| d|.d|.|0tdƒd}|$|.| g7}$q± n|d kr |9j9d|0ƒq± |:j9|0ƒq± Wqœ W||$Œ}|4j:dt;ƒ|5j:dt;ƒ|6j:dt;ƒ|7j:dt;ƒ|4|5f|6|7f|||fS(sœ 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) iÿÿÿÿ(trepeat(tPolyRŽR8RetCRootOftexptexpandtrootstilcmRŒtsintcosttantcottigcdt exp_polarc s¿ˆˆ|ƒƒ}ˆdkr.ˆtkr.tSˆdkrD|ˆkSˆdkrZ|ˆkS|ˆktkrptS|ˆktkr†tS|rdSˆjs«ˆjs«|jr¯dStdƒ‚dS(sU Decide whether pole at c lies to the left of the fundamental strip. sPole inside critical strip?N(R2R RZR/R%R”(Rytis_numer(RzR{R™Re(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytleftÛs     iics s|]}|j VqdS(N(t is_Rational(R<R)((s9lib/python2.7/site-packages/sympy/integrals/transforms.pys stGammasNonrational multiplierc stdˆd|ƒS(NsInverse MellinsUnrecognised form '%s'.(R(tfact(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt exception/sc sX|jˆƒsˆˆƒ‚nˆ|ˆƒ}|jƒdkrNˆˆƒ‚n|jƒS(s7 Test if arg is of form a*s+b, raise exception if not. i(t is_polynomialtdegreet all_coeffs(targtp(R–R§R¦R*(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt linear_arg:s s Gammas partially over the strip.tevaluateisa is not an integerRN(<t itertoolsR•R>R–RŽR8ReR—R˜R™RšR›RŒRœRRžRŸR R¡RRBR;R"RCtas_independentRKtis_realtabsR¤RARR2RtqRIR¬Rptas_numer_denomt make_argsRDtzipRZR/R@tis_PowRFtbaset is_IntegerR¨R©tLTt all_rootsRªR'R“t TypeErrorRRHRƒR(>R(R*RuRvR•RŽR8R—texp_RšR›RŒRœRRžRŸR R¡R£t s_multiplierstgR«RPt_R)tcommon_coefficientt s_multipliertfactexponenttnumertdenomR"tfacstdfacst numer_gammast denom_gammast exponentialsR¢tugammastlgammastufacstlfacsR­R¸R˜R4R¬trsRytgamma1tgamma2tfac_tantaptbmtbqtgammastplustminustnewatnewctk(( R–RzR{R§R™R(R¦ReR*s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_rewrite_gammas>/j     .     ,  /    4               '   && /$ ( *   %    00  c C s^ddlm}m}m}m}m} m} m} m} m } m }m }t dd|dt ƒ}|j|ƒ}xÒ| |ƒ||ƒ||ƒgD]¯}|jr^g|jD]$}t|||||dtƒ^q®}g|D]}|d^qß}g|D]}|d^qü}||Œ}|sB| |d |j| ƒƒ}n|j||ƒt|ŒfSy0t|||d|dƒ\}}}}}Wntk r¤q•nX||||||ƒ}|rÎ|}n§y||ƒ}Wn%tk r}td |d ƒ‚nX|jrut|jƒd kru| |t|ƒƒ|jdjd| t|ƒ|ƒ|jdjd}nt| |jƒƒ|j| kg}|ttt|jƒt|j ƒkd| |j!ƒdkƒt| |jƒƒ|j| kƒg7}t|Œ}|tkr-td |d ƒ‚n||j||ƒ|fSWtd |dƒ‚dS(ss A helper for the real inverse_mellin_transform function, this one here assumes x to be real and positive. iÿÿÿÿ( R™R7t hyperexpandtmeijergR«RŒRetfactort HeavisideRŽR6Rjsinverse-mellin-transformtpositiveR^iitgenssInverse MellinsCould not calculate integralisdoes not convergeR.N("R>R™R7RßRàR«RŒReRáRâRŽR6RRZtrewriteRCR"t_inverse_mellin_transformR/RBRpRRÞRR'R‚RIR²targumenttdeltaRRÕR×tnu(R†R*tx_tstript as_meijergR™R7RßRàR«RŒReRáRâRŽR6R)R¿tGROR¬RxRNRuRvtCteRÃthtdetailR4((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRæÅsJL( 1 0  %,%=)  tInverseMellinTransformcB sVeZdZdZedƒZedƒZd„Zed„ƒZ d„Z d„Z RS(sú 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. sInverse MellinR2RycK sO|dkrtj}n|dkr0tj}ntj|||||||S(N(R2Ròt_none_sentinelR!t__new__(tclsR†R*R)RuRvtopts((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRôs     cC sU|jd|jd}}|tjkr3d}n|tjkrKd}n||fS(Nii(R"RòRóR2(RRuRv((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytfundamental_strips   c K sddlm}tdkr¡ddlm}m}m}m} m} m } m } m } m }m }m}m}t|||| | | | | ||||g ƒanxT||ƒD]F}|jr®|j|ƒr®|jtkr®td|d|ƒ‚q®q®W|j}t|||||S(Niÿÿÿÿ(tpostorder_traversal( R˜RŽRœRRžRŸtcoshtsinhttanhtcotht factorialtrfsInverse MellinsComponent %s not recognised.(R>Røt_allowedR2R˜RŽRœRRžRŸRùRúRûRüRýRþtsett is_FunctionR;R=RR÷Ræ(RR†R*R)R+RøR˜RŽRœRRžRŸRùRúRûRüRýRþR(Rë((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,s R'  cC s]ddlm}|jj}t||| |||t||tfƒdtjtjS(Niÿÿÿÿ(tIi( R>RR0t_cR R RtPit ImaginaryUnit(RR†R*R)RRy((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-0s ( RRR RJR RóRRôRUR÷R,R-(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRòs    cK s't||||d|dƒj|S(s 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(1 - x)/2 - Heaviside(x - 1)/(2*x) >>> inverse_mellin_transform(f, s, x, (1, oo)) (-x/2 + 1/(2*x))*Heaviside(1 - x) See Also ======== mellin_transform hankel_transform, inverse_hankel_transform ii(RòRE(R†R*R)RëR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytinverse_mellin_transform6s0c sÌddlm}m}m‰ddlm‰‡fd†‰‡‡‡‡‡fd†‰‡‡fd†‰‡‡fd†}d„}|||ˆƒ}|||‡fd †ƒ}||ˆ|ƒ}t|ƒS( s¨ 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) iÿÿÿÿ(tStrictGreaterThantStrictLessThant Unequality(tAbsc s3|ˆkrdS|jr/|jˆkr/|jSdS(Ni(R·R¸R˜R2(tex(R*(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytpowers  c s |jˆƒr"|jˆƒr"dSt|ˆƒrA|jd}nt|ˆƒr`|jd}n|jˆƒr„ˆd|d|ƒSˆ|ƒ}|dkr dSyh|dkrÕt|ƒtˆƒ|ktkrÕtS|dkrt|ƒtˆƒ|ktkrtSWntk rnXdS(s_ Return True only if |ex1| > |ex2|, False only if |ex1| < |ex2|. Else return None. iiN(R;R2RFR"R²RZR/R¼(tex1tex2R‘(R RutbiggerR R*(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR”s$  .. c sf|jpt|ˆƒ s2|jp.t|ˆƒ r<||kSˆ||ƒ}|dk r\| S||kS(s simplify x < y N(t is_positiveRFR2(R)tyR’(R R(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytreplieªs  c s8ˆ||ƒ}|tks'|tkr+tSˆ||ƒS(N(RZR/(R)RRv(R R(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytreplue´scW s/|tks|tkr"t|ƒS|j|ŒS(N(RZR/tboolRo(R R"((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytreplºs c s ˆ||ƒS(N((R)R(R(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRm¿R.(tsympy.core.relationalRRR R>R R(R[R*RuRRRR((R R RuRR RR*s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_simplifycondsms  c  s“ddlm‰ m‰m}m‰m‰m‰m‰m‰m ‰m ‰ m ‰ t dƒ‰ t |ˆ ˆƒˆˆdtfƒ}|jtƒs´t|jˆ ˆ ƒ|ƒt tjfS|jsÒtdˆdƒ‚n|jd\}}|jtƒr tdˆdƒ‚n‡‡‡‡‡‡‡‡‡ ‡ ‡ ‡ ‡f d†}gt|ƒD]}||ƒ^qI} g| D]-} | d tkrh| dt krh| ^qh} | sÍg| D]} | d tkr¨| ^q¨} n| } d „‰| jd ‡fd †ƒ| stdˆd ƒ‚n| d\} } ‡ ‡ fd†}|r_t|ˆ | ƒ}t| ˆ | ƒ} nt|jˆ ˆ ƒ|ƒ|| ƒt|| ƒƒfS(s. The backend function for Laplace transforms. iÿÿÿÿ( ReRfR˜RŒRgtperiodic_argumentR«RtWildtsymbolst polar_liftR*itLaplacescould not compute integralsintegral in unexpected formc  s˜t }tj}tt|ƒƒ}ˆ ddˆdˆ gƒ\}}}}}}} |tˆˆ ||ƒƒ|k|tˆˆ ||ƒƒ|ktˆˆ ||||ƒƒ|ktˆˆ ||||ƒƒ|ktˆˆ ˆ |ƒ|||ƒƒ|ktˆˆ ˆ |ƒ|||ƒƒ|kf} xU|D]M} t} g} xt| ƒD]÷}|jr‰ˆ |jj kr‰|j }n|jr³t |t t fƒr³|j}nx'| D]}|j|ƒ‰ˆrºPqºqºWˆr-ˆ|jr-ˆ|ˆ|ˆdkr-ˆ ˆ ˆ|ƒ dk}q-n|j|ˆ|tˆˆ | ƒƒ|ƒtˆ |ƒ|dkƒ‰ˆsË|jˆ|tˆˆ || |ƒƒ|ƒtˆ |ƒ|dkƒ‰nˆs&|j|ˆtˆˆ ˆ ƒ|| |ƒƒ|ƒtˆ |ƒ|dkƒ‰nˆrpt‡fd†||||| gDƒƒrpˆ ˆ ƒˆ|k}n|jˆ d„ƒjˆ ˆ ƒˆ ƒ}|j sÏ|jd ksÏ|jˆ ƒsÏ|jˆ ƒ râ| |g7} q\nt|ˆ ƒ}|j s |jd kr| |g7} q\n|jˆ krAtd ˆd ƒ‚q\ˆ|j| ƒ} q\W| tkruˆ| |ƒ}q=t|t| Œƒ}q=W||fS(s7 Turn ``conds`` into a strip and auxiliary conditions. sp q w1 w2 w3 w4 w5Rõtexcludeiic3 s|]}ˆ|jVqdS(N(R(R<twild(R(s9lib/python2.7/site-packages/sympy/integrals/transforms.pys ýscS s|jƒjƒdS(Ni(R™Rl(R)((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRmR.s==s!=Rsconvergence not in half-plane?(s==s!=(s==s!=(R RRnRRR²RRqtrhsR%treversedRFRR t reversedsigntmatchRtallRoRpRrR;RVRsRRR(RxRuRwR¬R³tw1tw2tw3tw4tw5tpatternsRyRzR|R}tpatR~R( RfRgRR«targ_RR(RŒRReR*RRj(Rs9lib/python2.7/site-packages/sympy/integrals/transforms.pyR€Øsp -!!$$*0    )!II-"1!       icS s&|tks|tkrdS|jƒS(Ni(RZR/Rh(R[((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytcntsRc s|d ˆ|dƒfS(Nii((R)(R,(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRm R.sno convergence foundc s|jˆˆƒS(N(Rp(R[(R*R„(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytsbs&s(R>ReRfR˜RŒRgRR«RRRRR R R R;R R\RpRRnR‚RR"RR/RƒRR(R(RjR„RR˜R†R4R€RyRxR)tconds2RuRwR-((RfRgRR«R+R,RR(RŒRReR*R„RRjs9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_laplace_transformÄs8L '& 3>%:, tLaplaceTransformcB s/eZdZdZd„Zd„Zd„ZRS(så 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. RcK st||||S(N(R/(RR(RjR*R+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,:scC s5ddlm}t||| |ƒ|dtfƒS(Niÿÿÿÿ(R˜i(R>R˜R R (RR(RjR*R˜((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-=scC sddlm}g}g}x.|D]&\}}|j|ƒ|j|ƒq#Wt|Œ}||Œ}|tkr†tdddƒ‚n||fS(Niÿÿÿÿ(RfRsNo combined convergence.(R>RfRHRR/RR2(RR3RfRxtplanestplaneR4((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR5As    (RRR RJR,R-R5(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR0.s   c sSt|tƒr:t|dƒr:|j‡‡‡fd†ƒSt|ˆˆƒjˆS(sb 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 t applyfuncc st|ˆˆˆS(N(tlaplace_transform(tfij(R+R*Rj(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRmpR.(RFRthasattrR3R0RE(R(RjR*R+((R+R*Rjs9lib/python2.7/site-packages/sympy/integrals/transforms.pyR4Psc  sûddlm‰m‰m‰m‰m}m‰ddlm}m ‰t ddt ƒ‰‡‡‡‡fd†}y8t ||ˆˆ ƒdtfdt dtƒ\}} Wntk r¿d}nX|dkr`|||ˆƒ}|dkrÿtd |d ƒ‚n|jrB|jd \}} |j|ƒrKtd |d ƒ‚qKn tj} |jˆ|ƒ}n|jr|jˆ|ƒ| fSt d ƒ‰‡‡‡‡‡fd†} |jˆ| ƒ}‡‡fd†} |jˆ| ƒ}t|jˆ|ƒ|ƒ| fS(s6 The backend function for inverse Laplace transforms. iÿÿÿÿ(R˜Râtlogtexpand_complexR t Piecewise(tmeijerint_inversiont_get_coeff_expRjRkc s§t|ƒdkrˆ|ŒS|djdj}ˆ|ˆƒ\}}|djd}|djd}ˆdt|ƒˆ|ƒ|ˆˆ|dt|ƒƒ|S(s3 Simplify a piecewise expression from hyperexpand. iiii(RIR"RçR²(R"R«RPRÄte1te2(RâR9R;Rj(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytpw_simps R:R^sInverse LaplaceR.is(inversion integral of unrecognised form.tuc s•|jˆˆ ƒˆƒ}|jˆƒr2ˆ|ƒSt|dkˆƒ}|jˆkrsˆ|jƒ}ˆˆ|ƒSˆ|jƒ}ˆˆ| ƒSdS(Ni(RpR;RVRsRt(R«RutrelRÝ(RâR˜R7RjR?(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytsimp_heaviside¤s c sˆˆ|ƒƒS(N((R«(R˜R8(s9lib/python2.7/site-packages/sympy/integrals/transforms.pytsimp_exp±sN(R>R˜RâR7R8R R9tsympy.integrals.meijerintR:R;R RZRR2R R/RR‚R"R;RRnRoRpR\( R†R*tt_R2RR R:R>R(R4RARB((RâR9R;R˜R8R7RjR?s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_inverse_laplace_transformts8.           tInverseLaplaceTransformcB sVeZdZdZedƒZedƒZd„Zed„ƒZ d„Z d„Z RS(sý 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. sInverse LaplaceR2RycK s4|dkrtj}ntj||||||S(N(R2RFRóR!Rô(RõR†R*R)R2Rö((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRôÉs  cC s)|jd}|tjkr%d}n|S(Ni(R"RFRóR2(RR2((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytfundamental_planeÎs  cK st||||j|S(N(RERG(RR†R*RjR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,ÕscC shddlm}m}|jj}t|||ƒ||||t||tfƒdtjtj S(Niÿÿÿÿ(RR˜i( R>RR˜R0RR R RRR(RR†R*RjRR˜Ry((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-Øs ( RRR RJR RóRRôRURGR,R-(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRF»s    c sYt|tƒr=t|dƒr=|j‡‡‡‡fd†ƒSt|ˆˆˆƒjˆS(sé 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 R3c st|ˆˆˆˆS(N(tinverse_laplace_transform(tFij(R+R2R*Rj(s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRmR.(RFRR6R3RFRE(R†R*RjR2R+((R+R2R*Rjs9lib/python2.7/site-packages/sympy/integrals/transforms.pyRHÞs&c C s,ddlm}m}t|||||||ƒ|t tfƒ} | jtƒsnt| |ƒtj fSt||t tfƒ} | t ttj fks¯| jtƒrÄt ||dƒ‚n| j sât ||dƒ‚n| j d\} } | jtƒrt ||dƒ‚nt| |ƒ| fS(sÒ 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. iÿÿÿÿ(R˜Rs$function not integrable on real axisscould not compute integralisintegral in unexpected form(R>R˜RR R R;R R\RRntNaNRR‚R"( R(R)RÝRuRvR1RR˜RR†t integral_fR4((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_fourier_transform s 3( tFourierTypeTransformcB s2eZdZd„Zd„Zd„Zd„ZRS(s# Base class for Fourier transforms.cC std|jƒ‚dS(Ns,Class %s must implement a(self) but does not(R'R0(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRu-scC std|jƒ‚dS(Ns,Class %s must implement b(self) but does not(R'R0(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRv1scK s.t||||jƒ|jƒ|jj|S(N(RLRuRvR0RJ(RR(R)RÝR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,5s cC s_ddlm}m}|jƒ}|jƒ}t|||||||ƒ|t tfƒS(Niÿÿÿÿ(R˜R(R>R˜RRuRvR R (RR(R)RÝR˜RRuRv((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-:s  (RRR RuRvR,R-(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRM*s    tFourierTransformcB s&eZdZdZd„Zd„ZRS(så 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. tFouriercC sdS(Ni((R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRuMscC s dtjS(Niþÿÿÿ(RR(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRvPs(RRR RJRuRv(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRNAs cK st|||ƒj|S(sT 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 (RNRE(R(R)RÝR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytfourier_transformTs!tInverseFourierTransformcB s&eZdZdZd„Zd„ZRS(sý 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. sInverse FouriercC sdS(Ni((R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRu„scC s dtjS(Ni(RR(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRv‡s(RRR RJRuRv(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRQxs cK st|||ƒj|S(sz 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 (RQRE(R†RÝR)R+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytinverse_fourier_transform‹s!(RœRtsqrtRŒc C s»t||||||ƒ|dtfƒ}|jtƒsSt||ƒtjfS|jsqt||dƒ‚n|j d\}} |jtƒr¨t||dƒ‚nt||ƒ| fS(s  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. iscould not compute integralsintegral in unexpected form( R R R;R R\RRnR‚RR"( R(R)RÝRuRvtKR1RR†R4((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_sine_cosine_transform¶s . tSineCosineTypeTransformcB s2eZdZd„Zd„Zd„Zd„ZRS(sK Base class for sine and cosine transforms. Specify cls._kern. cC std|jƒ‚dS(Ns,Class %s must implement a(self) but does not(R'R0(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRuÕscC std|jƒ‚dS(Ns,Class %s must implement b(self) but does not(R'R0(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRvÙsc K s7t||||jƒ|jƒ|jj|jj|S(N(RURuRvR0t_kernRJ(RR(R)RÝR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,Þs  cC sP|jƒ}|jƒ}|jj}t||||||ƒ|dtfƒS(Ni(RuRvR0RWR R (RR(R)RÝRuRvRT((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-äs   (RRR RuRvR,R-(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRVÏs    t SineTransformcB s,eZdZdZeZd„Zd„ZRS(sÜ 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. tSinecC stdƒttƒS(Ni(RSRŒ(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRuøscC sdS(Ni((R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRvûs(RRR RJRœRWRuRv(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRXës  cK st|||ƒj|S(sõ 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**(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 (RXRE(R(R)RÝR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytsine_transformÿstInverseSineTransformcB s,eZdZdZeZd„Zd„ZRS(sô 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. s Inverse SinecC stdƒttƒS(Ni(RSRŒ(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRu-scC sdS(Ni((R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRv0s(RRR RJRœRWRuRv(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR[ s  cK st|||ƒj|S(s5 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 (R[RE(R†RÝR)R+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytinverse_sine_transform4stCosineTransformcB s,eZdZdZeZd„Zd„ZRS(sâ 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. tCosinecC stdƒttƒS(Ni(RSRŒ(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRucscC sdS(Ni((R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRvfs(RRR RJRRWRuRv(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR]Vs  cK st|||ƒj|S(sþ 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 (R]RE(R(R)RÝR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytcosine_transformjstInverseCosineTransformcB s,eZdZdZeZd„Zd„ZRS(sú 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. sInverse CosinecC stdƒttƒS(Ni(RSRŒ(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRu˜scC sdS(Ni((R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRv›s(RRR RJRRWRuRv(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR`‹s  cK st|||ƒj|S(sñ 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 (R`RE(R†RÝR)R+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytinverse_cosine_transformŸsc C sÊddlm}t|||||ƒ||dtfƒ}|jtƒsbt||ƒtjfS|j s€t ||dƒ‚n|j d\}}|jtƒr·t ||dƒ‚nt||ƒ|fS(sv Compute a general Hankel transform .. math:: F_\nu(k) = \int_{0}^\infty f(r) J_\nu(k r) r \mathrm{d} r. iÿÿÿÿ(tbesseljiscould not compute integralsintegral in unexpected form( R>RbR R R;R R\RRnR‚RR"( R(R’RÝRéR1RRbR†R4((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyt_hankel_transformÄs- tHankelTypeTransformcB s8eZdZd„Zd„Zd„Zed„ƒZRS(s+ Base class for Hankel transforms. cK s)|j|j|j|j|jd|S(Ni(R,RR#R$R"(RR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyREàs   cK st|||||j|S(N(RcRJ(RR(R’RÝRéR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR,çscC s;ddlm}t|||||ƒ||dtfƒS(Niÿÿÿÿ(Rbi(R>RbR R (RR(R’RÝRéRb((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyR-êscC s&|j|j|j|j|jdƒS(Ni(R-RR#R$R"(R((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRRîs (RRR RER,R-RURR(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRdÛs    tHankelTransformcB seZdZdZRS(sâ 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. tHankel(RRR RJ(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyReöscK st||||ƒj|S(s± 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 (ReRE(R(R’RÝRéR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pythankel_transforms(tInverseHankelTransformcB seZdZdZRS(sú 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. sInverse Hankel(RRR RJ(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pyRh.scK st||||ƒj|S(s¾ 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 (RhRE(R†RÝR’RéR+((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytinverse_hankel_transform;s(N(^R t __future__RRt sympy.coreRtsympy.core.compatibilityRRRR?RRRRR tsympy.core.numbersR tsympy.core.symbolR tsympy.integralsR R RCRtsympy.logic.boolalgRRRRRtsympy.simplifyRtsympy.utilitiesRtsympy.matrices.matricesRR'RR!tsympy.solvers.inequalitiesRVR\RcR/t_nocondsRdRZR‡RˆR‹R“t ValueErrorR”RÞRæR2RÿRòRRR/R0R4RERFRHRLRMRNRPRQRRR>RœRRSRŒRURVRXRZR[R\R]R_R`RaRcRdReRgRhRi(((s9lib/python2.7/site-packages/sympy/integrals/transforms.pytsˆ(„    D" ' + ÿ) 85 7 Wi" $ F# /  $ ("  ! " ! %  +