o o h$@sdZddlmZmZddlmZddlmZmZddl m Z ddl m Z m Z mZmZmZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZmZdd lm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDddlEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNmOZOddlPmQZQddlRmSZSddlTmUZUGd d!d!eVZWGd"d#d#eZXd$d%ZYd&d'ZZeZd(Z[d)d*Z\e[e\d+fd,d-Z]Gd.d/d/eXZ^d0d1Z_d2d3Z`Gd4d5d5eaZbd6d7ZceZd+dkd8d9Zdd:aeGd;d<dZgeZd+dld?d@ZhGdAdBdBeXZiGdCdDdDeiZjdEdFZkGdGdHdHeiZldIdJZmeZd+dldKdLZnGdMdNdNeXZoGdOdPdPeoZpdQdRZqGdSdTdTeoZrdUdVZsGdWdXdXeoZtdYdZZuGd[d\d\eoZvd]d^ZweZd+dld_d`ZxGdadbdbeXZyGdcddddeyZzdedfZ{GdgdhdheyZ|didjZ}dd:l~mmZejZejZejZejZejZejZd:S)mz Integral Transforms )reducewraps)repeat)Spi)Add) AppliedUndef count_opsexpand expand_mulFunction)Mul)igcdilcm)default_sort_key)Dummy)postorder_traversal) factorialrf)reargAbs)exp exp_polar)coshcothsinhtanh)ceiling)MaxMinsqrt)piecewise_fold)coscotsintan)besselj) Heaviside)gamma)meijerg) integrateIntegral)_dummy)to_cnf conjuncts disjunctsOrAnd)roots)factorPoly)CRootOf)iterable)debugcs eZdZdZfddZZS)IntegralTransformErrora Exception raised in relation to problems computing transforms. Explanation =========== This class is mostly used internally; if integrals cannot be computed objects representing unevaluated transforms are usually returned. The hint ``needeval=True`` can be used to disable returning transform objects, and instead raise this exception if an integral cannot be computed. cstd||f||_dS)Nz'%s Transform could not be computed: %s.)super__init__function)self transformr<msg __class__n/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/integrals/transforms.pyr;6s  zIntegralTransformError.__init__)__name__ __module__ __qualname____doc__r; __classcell__rBrBr@rCr9(s r9c@s|eZdZdZeddZeddZeddZedd Zd d Z d d Z ddZ ddZ ddZ eddZddZdS)IntegralTransforma} Base class for integral transforms. Explanation =========== This class represents unevaluated transforms. To implement a concrete transform, derive from this class and implement the ``_compute_transform(f, x, s, **hints)`` and ``_as_integral(f, x, s)`` functions. If the transform cannot be computed, raise :obj:`IntegralTransformError`. Also set ``cls._name``. For instance, >>> from sympy import LaplaceTransform >>> LaplaceTransform._name 'Laplace' Implement ``self._collapse_extra`` if your function returns more than just a number and possibly a convergence condition. cC |jdS)z! The function to be transformed. rargsr=rBrBrCr<S zIntegralTransform.functioncCrJ)z; The dependent variable of the function to be transformed. rKrMrBrBrCfunction_variableXrNz#IntegralTransform.function_variablecCrJ)z% The independent transform variable. rKrMrBrBrCtransform_variable]rNz$IntegralTransform.transform_variablecCs|jj|jh|jhS)zj This method returns the symbols that will exist when the transform is evaluated. )r< free_symbolsunionrRrPrMrBrBrCrSbszIntegralTransform.free_symbolscKtNNotImplementedErrorr=fxshintsrBrBrC_compute_transformkz$IntegralTransform._compute_transformcCrUrVrWr=rZr[r\rBrBrC _as_integralnr_zIntegralTransform._as_integralcCs$t|}|dkrt|jjdd|S)NF)r2r9rAname)r=extracondrBrBrC_collapse_extraqsz!IntegralTransform._collapse_extrac sd}tfddjtD }|r4zjjjjfi|}Wnty3tdd}Ynwj}|j s>t |}||fS)Nc3s|] }|jVqdSrV)hasrP).0funcrMrBrC ysz2IntegralTransform._try_directly..z6[IT _try ] Caught IntegralTransformError, returns None) anyr<atomsrr^rPrRr9r8is_Addr )r=r]T try_directlyfnrBrMrC _try_directlyws&    zIntegralTransform._try_directlyc  sdd}dd}|d<jd i\}}|dur |S|jr|d<fdd|jD}g}g}|D].} t| tsB| g} || dt| d krW|| d q8t| d krf|| d dg7}q8|dkrrt| }nt|}|sz|Sz |}t |r|ft|WS||fWSt yYnw|rt j jjd|j\} } | j t| gtjd dS) a Try to evaluate the transform in closed form. Explanation =========== This general function handles linearity, but apart from that leaves pretty much everything to _compute_transform. Standard hints are the following: - ``simplify``: whether or not to simplify the result - ``noconds``: if True, do not return convergence conditions - ``needeval``: if True, raise IntegralTransformError instead of returning IntegralTransform objects The default values of these hints depend on the concrete transform, usually the default is ``(simplify, noconds, needeval) = (True, False, False)``. needevalFsimplifyTNcs6g|]}j|gtjddjdiqS)rONrB)rAlistrLdoitrhr[r]r=rBrC s.z*IntegralTransform.doit..rrQrOrB)poprqrmrL isinstancetupleappendlenrrsrfr7r9rA_namer< as_coeff_mulrPr rt) r=r]rrrsrprnresrdressr[coeffrestrBrwrCrusR          &zIntegralTransform.doitcCs||j|j|jSrV)rar<rPrRrMrBrBrC as_integrals zIntegralTransform.as_integralcOs|jSrV)r)r=rLkwargsrBrBrC_eval_rewrite_as_Integralz+IntegralTransform._eval_rewrite_as_IntegralN)rDrErFrGpropertyr<rPrRrSr^rarfrqrurrrBrBrBrCrI<s$    G  rIcCs4|rddlm}ddlm}||t|ddS|S)Nr)rs) powdenestT)polar)sympy.simplifyrssympy.simplify.powsimprr")exprrursrrBrBrC _simplifys   rcsfdd}|S)aV This is a decorator generator for dropping convergence conditions. Explanation =========== Suppose you define a function ``transform(*args)`` which returns a tuple of the form ``(result, cond1, cond2, ...)``. Decorating it ``@_noconds_(default)`` will add a new keyword argument ``noconds`` to it. If ``noconds=True``, the return value will be altered to be only ``result``, whereas if ``noconds=False`` the return value will not be altered. The default value of the ``noconds`` keyword will be ``default`` (i.e. the argument of this function). cstdfdd }|S)Nnocondscs|i|}|r |dS|SNrrB)rrLrrrirBrCwrappersz0_noconds_..make_wrapper..wrapper)r)rirdefaultrrC make_wrappersz_noconds_..make_wrapperrB)rrrBrrC _noconds_s rFcCst||tjtjfSrV)r+rZeroInfinity)rZr[rBrBrC_default_integratorrTc stdd|||d||}|ts't|||tjtjftjfS|j s0t d|d|j d\}}|trBt d|dfdd fd d t |D}d d |D}|j d dd|sjt d|d|d\}} } t||||| f| fS)z0 Backend function to compute Mellin transforms. r\zmellin-transformrOMellincould not compute integralrintegral in unexpected formcsHddlm}tj}tj}tj}tt|}tddd}|D]}tj}tj} g} t |D]M} | t dd t |} | j rM| jdvsM| sM| |sS| | g7} q+|| |} | j r`| jdvrf| | g7} q+| j|krrt| j| } q+t| j|}q+|tjur||krt||}q| tjur| |krt| |}qt|t| }q|||fS) zN Turn ``cond`` into a strip (a, b), and auxiliary conditions. r)_solve_inequalitytT)realcSs |dSr) as_real_imagr[rBrBrC)s z:_mellin_transform..process_conds..)z==z!=)sympy.solvers.inequalitiesrrNegativeInfinityrtruer/r.rr0replacersubs is_Relationalrel_oprgltsrgtsr r2r1)rerabauxcondsrca_b_aux_dd_soln)r\rBrC process_condssL              z(_mellin_transform..process_condscsg|]}|qSrBrBrhr)rrBrCrx@z%_mellin_transform..cSsg|] }|ddkr|qS)rQFrBrvrBrBrCrxAcSs|d|dt|dfS)NrrOrQ)r rrBrBrCrBrz#_mellin_transform..keyzno convergence found)r-rgr,rrrrrr is_Piecewiser9rLr0sort) rZr[s_ integratorrsFrerrrrrB)rr\rC_mellin_transforms&  "   ' rc@s,eZdZdZdZddZddZddZd S) MellinTransformz Class representing unevaluated Mellin transforms. For usage of this class, see the :class:`IntegralTransform` docstring. For how to compute Mellin transforms, see the :func:`mellin_transform` docstring. rcKst|||fi|SrV)rrYrBrBrCr^Wrz"MellinTransform._compute_transformcCs t|||d|tjtjfSNrO)r,rrrr`rBrBrCraZs zMellinTransform._as_integralc Csg}g}g}|D]\\}}}||g7}||g7}||g7}qt|t|ft|f}|dd|ddkdks>|ddkrDtddd|S)NrrOTFrzno combined convergence.)rr r2r9) r=rdrrresasbrrrBrBrCrf]s   (zMellinTransform._collapse_extraN)rDrErFrGr~r^rarfrBrBrBrCrKs   rcKt|||jdi|S)a Compute the Mellin transform `F(s)` of `f(x)`, .. math :: F(s) = \int_0^\infty x^{s-1} f(x) \mathrm{d}x. For all "sensible" functions, this converges absolutely in a strip `a < \operatorname{Re}(s) < b`. Explanation =========== The Mellin transform is related via change of variables to the Fourier transform, and also to the (bilateral) Laplace transform. This function returns ``(F, (a, b), cond)`` where ``F`` is the Mellin transform of ``f``, ``(a, b)`` is the fundamental strip (as above), and ``cond`` are auxiliary convergence conditions. If the integral cannot be computed in closed form, this function returns an unevaluated :class:`MellinTransform` object. For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. If ``noconds=False``, then only `F` will be returned (i.e. not ``cond``, and also not the strip ``(a, b)``). Examples ======== >>> from sympy import mellin_transform, exp >>> from sympy.abc import x, s >>> mellin_transform(exp(-x), x, s) (gamma(s), (0, oo), True) See Also ======== inverse_mellin_transform, laplace_transform, fourier_transform hankel_transform, inverse_hankel_transform NrB)rru)rZr[r\r]rBrBrCmellin_transformls)rcCsp|\}}t|t}t|t}t| ||d}t||||td||||d|tfS)a Re-write the sine function ``sin(m*s + n)`` as gamma functions, compatible with the strip (a, b). Return ``(gamma1, gamma2, fac)`` so that ``f == fac/(gamma1 * gamma2)``. Examples ======== >>> from sympy.integrals.transforms import _rewrite_sin >>> from sympy import pi, S >>> from sympy.abc import s >>> _rewrite_sin((pi, 0), s, 0, 1) (gamma(s), gamma(1 - s), pi) >>> _rewrite_sin((pi, 0), s, 1, 0) (gamma(s - 1), gamma(2 - s), -pi) >>> _rewrite_sin((pi, 0), s, -1, 0) (gamma(s + 1), gamma(-s), -pi) >>> _rewrite_sin((pi, pi/2), s, S(1)/2, S(3)/2) (gamma(s - 1/2), gamma(3/2 - s), -pi) >>> _rewrite_sin((pi, pi), s, 0, 1) (gamma(s), gamma(1 - s), -pi) >>> _rewrite_sin((2*pi, 0), s, 0, S(1)/2) (gamma(2*s), gamma(1 - 2*s), pi) >>> _rewrite_sin((2*pi, 0), s, S(1)/2, 1) (gamma(2*s - 1), gamma(2 - 2*s), -pi) rrO)r rrrr))m_nr\rrmnrrBrBrC _rewrite_sins %  6rc@seZdZdZdS)MellinTransformStripErrorzF Exception raised by _rewrite_gamma. Mainly for internal use. N)rDrErFrGrBrBrBrCrsrc-st||g\fdd}g}tD]#}|sq|jd}|jr-|d}|\}} ||g7}qtt t t D]%}|sJqB|jd}|jrY|d}|\}} ||t g7}qBdd|D}tj |D] } | js}| nqtfdd|D}tdd |Drjstd d d ttd d|Dtj } | krt|dkr} n ttdd|D} | tj | } tj | } d urڈ| 9d ur| 9\}}t|}t|}tt|tdtt|td}g}g}g}g}g}fdd|r|\r(||}}|}n||}}|}fdd}sD|g7}njsNtt rjrYj!}j }nt"d}j }|j#r{}|dkrn| }|||fgt$|7}q|s||\}}sd|}|||g7}|||g7}ng%r#t&}|'dkr|(d}t)|}t||'krt*+|}||g7}|fdd|D7}q|,\}}||g7}|| }||r |tj | dfg7}|tj | fg7}n|dg7}|tj-|dfg7}|tj-|fg7}nttra|jd\}}rY|dkrE|| |dksU|dkrY|| |dkrYt.d|||fg7}nttrjd}rt|t td|t t } }!}"n t/||\} }!}"||  f|! fg7}||"g7}nett rÈjd}|t|ddftt d|dd fg7}nBtt rވjd}|tt d|ddfg7}n'tt rjd}|tt d|ddft|dd fg7}n|s| t|t|9} ggggf\}#}$}%}&||#|%df||&|$dffD]\}'}(})|'r|'\}}|dkr|dkrt$t|}||}*||}+|j#sWt0dt1|D]},|'|*|+|,|fg7}'q[r| dt d|d||tj29} |||g7}n| dt d|d||tj2} ||| g7}q.|dkr|(3d|n|)3||'s1q(t|}|#j4t5d|$j4t5d|%j4t5d|&j4t5d|#|$f|%|&f|| | fS)a Try to rewrite the product f(s) as a product of gamma functions, so that the inverse Mellin transform of f can be expressed as a meijer G function. Explanation =========== Return (an, ap), (bm, bq), arg, exp, fac such that G((an, ap), (bm, bq), arg/z**exp)*fac is the inverse Mellin transform of f(s). Raises IntegralTransformError or MellinTransformStripError on failure. It is asserted that f has no poles in the fundamental strip designated by (a, b). One of a and b is allowed to be None. The fundamental strip is important, because it determines the inversion contour. This function can handle exponentials, linear factors, trigonometric functions. This is a helper function for inverse_mellin_transform that will not attempt any transformations on f. Examples ======== >>> from sympy.integrals.transforms import _rewrite_gamma >>> from sympy.abc import s >>> from sympy import oo >>> _rewrite_gamma(s*(s+3)*(s-1), s, -oo, oo) (([], [-3, 0, 1]), ([-2, 1, 2], []), 1, 1, -1) >>> _rewrite_gamma((s-1)**2, s, -oo, oo) (([], [1, 1]), ([2, 2], []), 1, 1, 1) Importance of the fundamental strip: >>> _rewrite_gamma(1/s, s, 0, oo) (([1], []), ([], [0]), 1, 1, 1) >>> _rewrite_gamma(1/s, s, None, oo) (([1], []), ([], [0]), 1, 1, 1) >>> _rewrite_gamma(1/s, s, 0, None) (([1], []), ([], [0]), 1, 1, 1) >>> _rewrite_gamma(1/s, s, -oo, 0) (([], [1]), ([0], []), 1, 1, -1) >>> _rewrite_gamma(1/s, s, None, 0) (([], [1]), ([0], []), 1, 1, -1) >>> _rewrite_gamma(1/s, s, -oo, None) (([], [1]), ([0], []), 1, 1, -1) >>> _rewrite_gamma(2**(-s+3), s, -oo, oo) (([], []), ([], []), 1/2, 1, 8) cstt|}durtjurdSdur|kSdur!|kS|kdkr)dS|kdkr1dS|r5dSjs>js>|jr@dStd)zU Decide whether pole at c lies to the left of the fundamental strip. NTFzPole inside critical strip?)r rrrrSr)ris_numer)rrrBrCleft s   z_rewrite_gamma..leftrrOcSsg|] }|jr t|n|qSrB)is_extended_realrrvrBrBrCrx8sz"_rewrite_gamma..csg|]}|qSrBrBrv)common_coefficientrBrCrx>rcss|]}|jVqdSrV) is_RationalrvrBrBrCrj?sz!_rewrite_gamma..GammaNzNonrational multipliercSg|]}t|jqSrB)rqrvrBrBrCrxBscSrrB)rprvrBrBrCrxIsTFcstdd|S)NInverse MellinzUnrecognised form '%s'.)r9)fact)rZrBrC exceptionaz!_rewrite_gamma..exceptioncs8|s t|}|dkr|S)z7 Test if arg is of form a*s+b, raise exception if not. rO) is_polynomialr5degree all_coeffs)rr)rrr\rBrC linear_argls   z"_rewrite_gamma..linear_argcsg|]}|fqSrBrBr)rr\rBrCrxsrz Gammas partially over the strip.)evaluaterQza is not an integerr)6rrlr)rgrLrmas_independentrr%r#r&r$rOnerallrr9rrr}rras_numer_denomr make_argsrtziprryis_Powrzrbaser is_Integerrrr5rLTr3r6 all_rootsr NegativeOnerXr TypeErrorrangeHalfr|rr)-rZr\rrr s_multipliersgrr_r[ s_multiplierfacexponentnumerdenomrLfacsdfacs numer_gammas denom_gammas exponentialsugammaslgammasufacsrrexp_rerrsrgamma1gamma2fac_anapbmbqgammasplusminusnewanewckrB)rrrrrZrrr\rC_rewrite_gammasT?             $                        &        h     &&      rc sBtdd|dd|t}t|t|t|fD]}|jrTfdd|jD}dd|D}dd|D}t|}sHt|| t d }| |t |fSzt |d d \} } } } } Wn tyoYqwz t| | | | }Wn tyYqwr|}nDz d d lm}||}Wn tytd |dw|jrt|jdkrt t| |jd jd t t| |jd jd }tt|j|jtkg}|t tt|jt|jkd t|jd ktt|j|jtkg7}t|}|dkrtd |d||  ||fStd |d)zs A helper for the real inverse_mellin_transform function, this one here assumes x to be real and positive. rzinverse-mellin-transformT)positivec s g|] }t|ddqS)Fr)_inverse_mellin_transform)rhG as_meijergr\stripr[rBrCrxs   z-_inverse_mellin_transform..cSg|]}|dqS)rOrBrhrrBrBrCrxrcSr)rrBrrBrBrCrxr)gensrrO) hyperexpandrzCould not calculate integralFzdoes not convergerb) r-rewriter)r4r r rmrLrrlr(rr2rr9r* ValueErrorrrrXrr}rrargumentdeltarr1r r rnu)rr\x_rrrrrrrrCerrhrrerBrrCrs` $     *  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. rNonercKs8|durtj}|durtj}tj||||||fi|SrV)r'_none_sentinelrI__new__)clsrr\r[rroptsrBrBrCr*Cs zInverseMellinTransform.__new__cCs:|jd|jd}}|tjurd}|tjurd}||fS)Nr)rLr'r))r=rrrBrBrCfundamental_stripJs   z(InverseMellinTransform.fundamental_stripc Ks|ddtdurtttttttt t t t t h at|D]}|jr3||r3|jtvr3td|d|q|j}t||||fi|S)NrsTrzComponent %s not recognised.)ry_allowedrr)r%r#r&r$rrrrrrr is_Functionrgrir9r.r)r=rr\r[r]rZrrBrBrCr^Ss  z)InverseMellinTransform._compute_transformcCsJ|jj}t||| ||tjtj|tjtjfdtjtjSNrQ)rA_cr,r ImaginaryUnitrPi)r=rr\r[rrBrBrCracs   z#InverseMellinTransform._as_integralN) rDrErFrGr~rr)r2r*rr.r^rarBrBrBrCr'5s   r'cKs$t||||d|djdi|S)a" Compute the inverse Mellin transform of `F(s)` over the fundamental strip given by ``strip=(a, b)``. Explanation =========== This can be defined as .. math:: f(x) = \frac{1}{2\pi i} \int_{c - i\infty}^{c + i\infty} x^{-s} F(s) \mathrm{d}s, for any `c` in the fundamental strip. Under certain regularity conditions on `F` and/or `f`, this recovers `f` from its Mellin transform `F` (and vice versa), for positive real `x`. One of `a` or `b` may be passed as ``None``; a suitable `c` will be inferred. If the integral cannot be computed in closed form, this function returns an unevaluated :class:`InverseMellinTransform` object. Note that this function will assume x to be positive and real, regardless of the SymPy assumptions! For a description of possible hints, refer to the docstring of :func:`sympy.integrals.transforms.IntegralTransform.doit`. Examples ======== >>> from sympy import inverse_mellin_transform, oo, gamma >>> from sympy.abc import x, s >>> inverse_mellin_transform(gamma(s), s, x, (0, oo)) exp(-x) The fundamental strip matters: >>> f = 1/(s**2 - 1) >>> inverse_mellin_transform(f, s, x, (-oo, -1)) x*(1 - 1/x**2)*Heaviside(x - 1)/2 >>> inverse_mellin_transform(f, s, x, (-1, 1)) -x*Heaviside(1 - x)/2 - Heaviside(x - 1)/(2*x) >>> inverse_mellin_transform(f, s, x, (1, oo)) (1/2 - x**2/2)*Heaviside(1 - x)/x See Also ======== mellin_transform hankel_transform, inverse_hankel_transform rrONrB)r'ru)rr\r[rr]rBrBrCinverse_mellin_transformis$5r5c Cst||t|tj|||tjtjf}|ts$t||tj fSt||tjtjf}|tjtjtj fvs=|trCt ||d|j sLt ||d|j d\}} |tr^t ||dt||| fS)z Compute a general Fourier-type transform .. math:: F(k) = a \int_{-\infty}^{\infty} e^{bixk} f(x)\, dx. For suitable choice of *a* and *b*, this reduces to the standard Fourier and inverse Fourier transforms. z$function not integrable on real axisrrr)r+rrr3rrrgr,rrNaNr9rrL) rZr[rrrrcrsr integral_frerBrBrC_fourier_transforms.     r8c@0eZdZdZddZddZddZdd Zd S) FourierTypeTransformz# Base class for Fourier transforms.cCtd|jNz,Class %s must implement a(self) but does notrXrArMrBrBrCrzFourierTypeTransform.acCr;Nz,Class %s must implement b(self) but does notr=rMrBrBrCrr>zFourierTypeTransform.bcKs&t||||||jjfi|SrV)r8rrrAr~r=rZr[rr]rBrBrCr^s  z'FourierTypeTransform._compute_transformcCs>|}|}t||t|tj|||tjtjfSrV)rrr,rrr3rr)r=rZr[rrrrBrBrCras.z!FourierTypeTransform._as_integralNrDrErFrGrrr^rarBrBrBrCr:s  r:c@$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. FouriercCdSrrBrMrBrBrCrr_zFourierTransform.acC dtjS)Nrr4rMrBrBrCr zFourierTransform.bNrDrErFrGr~rrrBrBrBrCrC   rCcKr)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 NrB)rCrurZr[rr]rBrBrCfourier_transform'rMc@rB)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 FouriercCrErrBrMrBrBrCr#r_zInverseFourierTransform.acCrFr1rHrMrBrBrCr&rIzInverseFourierTransform.bNrJrBrBrBrCrOrKrOcKr)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 NrB)rOrurrr[r]rBrBrCinverse_fourier_transform*rNrQc Cst|||||||tjtjf}|ts!t||tjfS|js*t ||d|j d\}} |trzSineCosineTypeTransform.acCr;r?r=rMrBrBrCr{r>zSineCosineTypeTransform.bcKs,t||||||jj|jjfi|SrV)rSrrrA_kernr~r@rBrBrCr^s z*SineCosineTypeTransform._compute_transformcCs@|}|}|jj}t|||||||tjtjfSrV)rrrArUr,rrr)r=rZr[rrrrRrBrBrCras(z$SineCosineTypeTransform._as_integralNrArBrBrBrCrTqs  rTc@(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. SinecCtdttSr1r!rrMrBrBrCrrzSineTransform.acCtjSrVrrrMrBrBrCrrzSineTransform.bN rDrErFrGr~r%rUrrrBrBrBrCrW   rWcKr)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 NrB)rWrurLrBrBrCsine_transform$r_c@rV)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 SinecCrYr1rZrMrBrBrCrrzInverseSineTransform.acCr[rVr\rMrBrBrCrrzInverseSineTransform.bNr]rBrBrBrCrar^racKr)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 NrB)rarurPrBrBrCinverse_sine_transforms%rbc@rV)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. CosinecCrYr1rZrMrBrBrCrrzCosineTransform.acCr[rVr\rMrBrBrCrrzCosineTransform.bN rDrErFrGr~r#rUrrrBrBrBrCrcr^rccKr)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 NrB)rcrurLrBrBrCcosine_transformr`rfc@rV)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 CosinecCrYr1rZrMrBrBrCrLrzInverseCosineTransform.acCr[rVr\rMrBrBrCrOrzInverseCosineTransform.bNrerBrBrBrCrg?r^rgcKr)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 NrB)rgrurPrBrBrCinverse_cosine_transformSr`rhcCst|t|||||tjtjf}|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. rrr) r+r'rrrrgr,rrrr9rL)rZrrr"rcrsrrerBrBrC_hankel_transform~s&    ric@s4eZdZdZddZddZddZedd Zd S) HankelTypeTransformz+ Base class for Hankel transforms. cKs$|j|j|j|j|jdfi|SNr)r^r<rPrRrL)r=r]rBrBrCruszHankelTypeTransform.doitcKst|||||jfi|SrV)rir~)r=rZrrr"r]rBrBrCr^sz&HankelTypeTransform._compute_transformcCs&t|t|||||tjtjfSrV)r,r'rrr)r=rZrrr"rBrBrCras&z HankelTypeTransform._as_integralcCs||j|j|j|jdSrk)rar<rPrRrLrMrBrBrCrs zHankelTypeTransform.as_integralN) rDrErFrGrur^rarrrBrBrBrCrjsrjc@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. HankelNrDrErFrGr~rBrBrBrCrm rmcKt||||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 NrB)rmru)rZrrr"r]rBrBrChankel_transform.rrc@rl)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 HankelNrorBrBrBrCrtrprtcKrq)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 NrB)rtru)rrrr"r]rBrBrCinverse_hankel_transformrsru)F)T)rG functoolsrr itertoolsr sympy.corerrsympy.core.addrsympy.core.functionrr r r r sympy.core.mulr sympy.core.intfuncrrsympy.core.sortingrsympy.core.symbolrsympy.core.traversalr(sympy.functions.combinatorial.factorialsrr$sympy.functions.elementary.complexesrrr&sympy.functions.elementary.exponentialrr%sympy.functions.elementary.hyperbolicrrrr#sympy.functions.elementary.integersr(sympy.functions.elementary.miscellaneousrr r!$sympy.functions.elementary.piecewiser"(sympy.functions.elementary.trigonometricr#r$r%r&sympy.functions.special.besselr''sympy.functions.special.delta_functionsr('sympy.functions.special.gamma_functionsr)sympy.functions.special.hyperr*sympy.integralsr+r,sympy.integrals.meijerintr-sympy.logic.boolalgr.r/r0r1r2sympy.polys.polyrootsr3sympy.polys.polytoolsr4r5sympy.polys.rootoftoolsr6sympy.utilities.iterablesr7sympy.utilities.miscr8rXr9rIrr_nocondsrrrrrrrrrr/r'r5r8r:rCrMrOrQrSrTrWr_rarbrcrfrgrhrirjrmrrrtrusympy.integrals.laplace integralslaplace_laplaceLaplaceTransformlaplace_transformlaplace_correspondencelaplace_initial_condsInverseLaplaceTransforminverse_laplace_transformrBrBrBrCs                 D!,-- :4< *. '('+  1 6