B
    d‹dV9 ã               @   s&  d Z ddlmZmZ ddlmZ ddlm	Z	m
Z
 ddlmZ ddlmZ ddlmZ ddlmZ dd	lmZmZmZmZmZ dd
lmZ ddlmZmZmZ ddlmZm Z m!Z! ddl"m#Z#m$Z$ ddl%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 ddl7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z>m?Z?m@Z@mAZA ddlBmCZC ddlDmEZEmFZF ddlGmHZHmIZImJZJmKZK ddlLmMZMmNZNmOZOmPZP ddlQmRZRmSZS ddlTmUZUmVZV ddlWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZb ddlcmdZd ddlemfZfmgZg ddlhmiZi ddljmkZk dd llmmZmmnZnmoZompZpmqZq dd!lrmsZsmtZt dd"lumvZv dd#lwmxZxmyZymzZzm{Z{m|Z|m}Z} dd$l~mZ dd%l€mZ‚ e&d&ƒZƒd'd(„ Z„d)d*„ Z…dd+l†m‡Z‡ e‡d,ƒZˆd-d.„ Z‰G d/d0„ d0eŠƒZ‹d1d2„ ZŒd3d4„ Zd5d6„ ZŽd7d8„ Zd9d:„ Zd;d<„ Z‘d=d>„ Z’d?d@„ Z“dAdB„ Z”dCdD„ Z•i a–dEdF„ Z—dGdH„ Z˜dIdJ„ Z™d~dLdM„ZšdNdO„ Z›ddQdR„ZœdSdT„ Zd€dUdV„ZždWdX„ ZŸddYdZ„Z d[d\„ Z¡d]d^„ Z¢d_d`„ Z£dadb„ Z¤dcdd„ Z¥dea¦eeˆd‚dfdg„ƒƒZ§dƒdhdi„Z¨djdk„ Z©dldm„ Zªdndo„ Z«eˆdpdq„ ƒZ¬drds„ Z­dtdu„ Z®dvdw„ Z¯dxdy„ Z°eˆd„dzd{„ƒZ±d|d}„ Z²deS )…a¿  
Integrate functions by rewriting them as Meijer G-functions.

There are three user-visible functions that can be used by other parts of the
sympy library to solve various integration problems:

- meijerint_indefinite
- meijerint_definite
- meijerint_inversion

They can be used to compute, respectively, indefinite integrals, definite
integrals over intervals of the real line, and inverse laplace-type integrals
(from c-I*oo to c+I*oo). See the respective docstrings for details.

The main references for this are:

[L] Luke, Y. L. (1969), The Special Functions and Their Approximations,
    Volume 1

[R] Kelly B. Roach.  Meijer G Function Representations.
    In: Proceedings of the 1997 International Symposium on Symbolic and
    Algebraic Computation, pages 205-211, New York, 1997. ACM.

[P] A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
    Integrals and Series: More Special Functions, Vol. 3,.
    Gordon and Breach Science Publisher
é    )ÚDictÚTuple)ÚSYMPY_DEBUG)ÚSÚExpr)ÚAdd)Úcacheit)r   )Úfactor_terms)ÚexpandÚ
expand_mulÚexpand_power_baseÚexpand_trigÚFunction)ÚMul)ÚilcmÚRationalÚpi)ÚEqÚNeÚ_canonical_coeff)Údefault_sort_keyÚordered)ÚDummyÚsymbolsÚWild)Ú	factorial)ÚreÚimÚargÚAbsÚsignÚ
unpolarifyÚpolarifyÚ
polar_liftÚprincipal_branchÚunbranched_argumentÚperiodic_argument)ÚexpÚ	exp_polarÚlog)Úceiling)ÚcoshÚsinhÚ_rewrite_hyperbolics_as_expÚHyperbolicFunction)Úsqrt)Ú	PiecewiseÚpiecewise_fold)ÚcosÚsinÚsincÚTrigonometricFunction)ÚbesseljÚbesselyÚbesseliÚbesselk)Ú
DiracDeltaÚ	Heaviside)Ú
elliptic_kÚ
elliptic_e)ÚerfÚerfcÚerfiÚEiÚexpintÚSiÚCiÚShiÚChiÚfresnelsÚfresnelc)Úgamma)ÚhyperÚmeijerg)ÚSingularityFunctioné   )ÚIntegral)ÚAndÚOrÚBooleanAtomÚNotÚBooleanFunction)ÚcancelÚfactor)Úsincos_to_sum)ÚcollectÚ	gammasimpÚhyperexpandÚ	powdenestÚpowsimpÚsimplify)Úmultiset_partitions)ÚdebugÚzc                s6   t | ƒ} t| ddƒr,t‡ fdd„| jD ƒƒS | jˆ Ž S )NÚis_PiecewiseFc             3   s   | ]}t |fˆ žŽ V  qd S )N)Ú_has)Ú.0Úi)Úf© úf/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/sympy/integrals/meijerint.pyú	<genexpr>R   s    z_has.<locals>.<genexpr>)r1   ÚgetattrÚallÚargsÚhas)Úresrd   re   )rd   rf   ra   M   s    ra   c                s4	  dd„ }t t|dƒƒ\‰‰‰‰}tddd„ gd‰ˆtˆ  ‰	ˆ	tjddf‡
fd	d
„	‰d'‡
fdd„	}dd„ }ˆ|ˆƒddfgˆ
d< G dd„ dtƒ}ˆtˆ	ˆ ƒˆ	ˆ ˆd   ˆgg g dgˆ	ˆ tˆƒˆˆd   t	ˆdkƒƒ ˆtˆˆ	 ƒˆˆ	 ˆd   g ˆgdgg ˆ	ˆ tˆƒˆˆd   t	ˆdkƒƒ ˆttˆˆ dˆ   ƒˆ	ˆ ˆd   ˆgg g dgˆ	ˆ tˆƒˆˆd   t	ˆdkƒƒ ˆtˆˆ dˆ  t ƒˆˆ	 ˆd   g ˆgdgg ˆ	ˆ tˆƒˆˆd   t	ˆdkƒƒ ˆˆˆ	 ˆ  dˆ gg dgg ˆ	ˆ ˆˆ  tˆƒ t
|ˆƒƒd ˆtˆˆ	 ƒˆ  dˆ gdˆ d gdgdˆ d gˆ	ˆ dttˆ d ƒ tdˆ ƒ tˆƒˆ   tˆƒdk ƒ ˆˆ	ˆ ˆˆ  ˆ	ˆ  dˆgg dˆgg ˆ	ˆ ˆˆd  tˆt ƒ t ƒ dd„ ‰ ‡ ‡‡‡‡	fdd„}|ddƒ |ddƒ |tjdƒ |tjdƒ ‡ ‡‡‡‡‡fdd„}|ddƒ |ddƒ |tjdƒ |tjdƒ ˆttdƒˆ	 ƒg g dgg ƒ ˆtˆ	ƒg dgtjgddgˆ	d d ttddƒ ƒ ˆtˆ	ƒg tjgdgtjtjgˆ	d d ttddƒ ƒ ˆtˆ	ƒg g tjgdgˆ	d d ttƒƒ ˆtˆ	ƒg g dgtjgˆ	d d ttƒƒ ˆtˆ	ƒg g dgtddƒgˆ	d d ttƒd ƒ ‡‡	fdd„‰‡‡	fd d!„‰|tˆ	ƒˆ tdˆ	 ƒ ˆdƒ |tˆ	ƒˆ tˆ	d ƒ ˆdƒ ‡‡fd"d#„}|tˆ	ƒˆ |dƒ |tˆ	ˆ ƒ|tˆƒƒtjtddgg dgdgˆ	ˆ ƒfg dƒ |ttˆ	ˆ ƒƒ|ttˆƒƒƒttddgtjgdgdtjgˆ	ˆ ƒfg dƒ |tˆ	ƒ|tj t ƒtjtg dgddgg ˆ	tdƒ ƒfg dƒ ˆtˆ	ƒdgg tjgddgˆ	d d ttƒd ƒ ˆtˆ	ƒg dgddgtjgˆ	d d ttƒ d ƒ ˆtˆ	ƒtjgg dgtddƒtddƒgtdƒˆ	d  d ˆ	ttƒ d ƒ ˆt ˆ	ƒg tjdgddgtjtjgˆ	d d ttd$ƒ  d ƒ ˆt!ˆˆ	ƒg ˆgˆd dgg ˆ	ƒ ˆt"ˆ	ƒdgg tjgdgˆ	d dttƒ ƒ ˆt#ˆ	ƒg dgdtjgg ˆ	d dttƒ ƒ ˆt$ˆ	ƒtjgg dgtddƒgˆ	d  ˆ	ttƒ ƒ ˆt%ˆ	ƒdgg tddƒgdtddƒgtd ˆ	d  d% tjƒ ˆt&ˆ	ƒdgg tddƒgdtddƒgtd ˆ	d  d% tjƒ ˆt'ˆˆ	ƒg g ˆd gˆ d gˆ	d d ƒ ˆt(ˆˆ	ƒg ˆd  d gˆd ˆ d gˆd  d gˆ	d d ƒ ˆt)ˆˆ	ƒg dˆ d gˆd gˆ d dˆ d gˆ	d d tƒ ˆt*ˆˆ	ƒg g ˆd ˆ d gg ˆ	d d tjƒ ˆt+ˆ	ƒtjtjgg dgdgˆ	 tjƒ ˆt,ˆ	ƒtjdtj gg dgdgˆ	 tddƒd ƒ d&S )(z8 Add formulae for the function -> meijerg lookup table. c             S   s   t | tgdS )N)Úexclude)r   r_   )Únre   re   rf   ÚwildX   s    z"_create_lookup_table.<locals>.wildZpqabcrn   c             S   s   | j o| dkS )Nr   )Ú
is_Integer)Úxre   re   rf   Ú<lambda>[   ó    z&_create_lookup_table.<locals>.<lambda>)Ú
propertiesTc	       	   
      s6   ˆ   t| tƒg ¡ | |t|||||ƒfg||f¡ d S )N)Ú
setdefaultÚ_mytyper_   ÚappendrK   )	ÚformulaÚanÚapÚbmÚbqr   ÚfacÚcondÚhint)Útablere   rf   Úadd^   s    z!_create_lookup_table.<locals>.addc                s$   ˆ   t| tƒg ¡ | |||f¡ d S )N)ru   rv   r_   rw   )rx   Úinstr~   r   )r€   re   rf   Úaddib   s    z"_create_lookup_table.<locals>.addic             S   s0   | t dgg g dgtƒf| t g dgdgg tƒfgS )NrM   r   )rK   r_   )Úare   re   rf   Úconstantf   s    z&_create_lookup_table.<locals>.constantre   c               @   s   e Zd Zedd„ ƒZdS )z2_create_lookup_table.<locals>.IsNonPositiveIntegerc             S   s   t |ƒ}|jdkr|dkS d S )NTr   )r!   rp   )Úclsr   re   re   rf   Úevaln   s    
z7_create_lookup_table.<locals>.IsNonPositiveInteger.evalN)Ú__name__Ú
__module__Ú__qualname__Úclassmethodr‡   re   re   re   rf   ÚIsNonPositiveIntegerl   s   rŒ   rM   r   )r   é   c             S   s(   t tddƒ | | d dd|     S )Néÿÿÿÿr   rM   )r   r   )Úrr    Únure   re   rf   ÚA1†   s    z _create_lookup_table.<locals>.A1c                s˜   ˆt ˆd ˆ ƒ|ˆ  ˆ ˆd ˆ |   dˆ d dd|   ˆd  gg ˆ|ˆ  d gˆ|ˆ  d gˆˆd  ˆˆd|    ˆ | |ˆƒ ƒ d S )Nr   rM   )r/   )r   Úsgn)r‘   r„   r   ÚbÚtre   rf   Útmpadd‰   s    , *z$_create_lookup_table.<locals>.tmpaddrŽ   c                s¦   ˆt ˆˆtˆ   ƒ|t ˆƒ tˆd    ˆ ˆˆtˆ   |   d|  |ˆ d  gd|  |ˆ d  gdtjgg ˆtˆ  ˆ ˆˆd |   ˆ | |ˆƒ ƒ d S )Nr   rM   r   )r/   r_   r   ÚHalf)r   r’   )r‘   r„   r   r“   ÚpÚqre   rf   r•   •   s    D2é   é   c                s@   | ˆ  }t j| t|ƒ tg dg|d  dg|d  g ˆƒfgS )NrM   r   )r   ÚNegativeOner   rK   )ÚsubsÚN)rn   r”   re   rf   Ú	make_log1°   s    z'_create_lookup_table.<locals>.make_log1c                s6   | ˆ  }t |ƒtdg|d  g g dg|d  ˆƒfgS )NrM   r   )r   rK   )rœ   r   )rn   r”   re   rf   Ú	make_log2µ   s    z'_create_lookup_table.<locals>.make_log2c                s   ˆ | ƒˆ| ƒ S )Nre   )rœ   )rž   rŸ   re   rf   Ú	make_log3¿   s    z'_create_lookup_table.<locals>.make_log3z3/2é   N)T)-ÚlistÚmapr   r_   r   ÚOner   r;   rI   rO   rR   r   r3   r   r   r–   r'   r#   r,   r   r+   r/   r2   r4   r)   rK   rA   ÚImaginaryUnitr›   rC   rD   rE   rF   rB   r>   r?   r@   rG   rH   r6   r7   r8   r9   r<   r=   )r€   ro   Úcrƒ   r…   rŒ   r•   r    re   )r‘   r„   r   r“   rž   rŸ   rn   r—   r˜   r”   r€   rf   Ú_create_lookup_tableV   s”    
. . : : 4<:.



48**2  .*	"248,",,4>>.FD2(r§   )ÚtimethisrK   c                sd   ˆ | j krdS | jrt| ƒfS ‡ fdd„| jD ƒ}g }x|D ]}|t|ƒ7 }q<W | ¡  t|ƒS dS )z4 Create a hashable entity describing the type of f. re   c                s   g | ]}t |ˆ ƒ‘qS re   )rv   )rb   r„   )rq   re   rf   ú
<listcomp>2  s    z_mytype.<locals>.<listcomp>N)Úfree_symbolsZis_FunctionÚtyperj   r¢   ÚsortÚtuple)rd   rq   Útypesrl   r”   re   )rq   rf   rv   +  s    


rv   c               @   s   e Zd ZdZdS )Ú_CoeffExpValueErrorzD
    Exception raised by _get_coeff_exp, for internal use only.
    N)rˆ   r‰   rŠ   Ú__doc__re   re   re   rf   r¯   :  s   r¯   c             C   sn   t t| ƒƒ |¡\}}|s$|tjfS |\}|jrL|j|krBtdƒ‚||jfS ||kr^|tj	fS td|  ƒ‚dS )aŒ  
    When expr is known to be of the form c*x**b, with c and/or b possibly 1,
    return c, b.

    Examples
    ========

    >>> from sympy.abc import x, a, b
    >>> from sympy.integrals.meijerint import _get_coeff_exp
    >>> _get_coeff_exp(a*x**b, x)
    (a, b)
    >>> _get_coeff_exp(x, x)
    (1, 1)
    >>> _get_coeff_exp(2*x, x)
    (2, 1)
    >>> _get_coeff_exp(x**3, x)
    (1, 3)
    zexpr not of form a*x**bzexpr not of form a*x**b: %sN)
r   r[   Úas_coeff_mulr   ÚZeroÚis_PowÚbaser¯   r'   r¤   )Úexprrq   r¦   Úmre   re   rf   Ú_get_coeff_expA  s    



r·   c                s"   ‡ fdd„‰ t ƒ }ˆ | ||ƒ |S )a  
    Find the exponents of ``x`` (not including zero) in ``expr``.

    Examples
    ========

    >>> from sympy.integrals.meijerint import _exponents
    >>> from sympy.abc import x, y
    >>> from sympy import sin
    >>> _exponents(x, x)
    {1}
    >>> _exponents(x**2, x)
    {2}
    >>> _exponents(x**2 + x, x)
    {1, 2}
    >>> _exponents(x**3*sin(x + x**y) + 1/x, x)
    {-1, 1, 3, y}
    c                sZ   | |kr|  dg¡ d S | jr:| j|kr:|  | jg¡ d S x| jD ]}ˆ |||ƒ qBW d S )NrM   )Úupdater³   r´   r'   rj   )rµ   rq   rl   Úargument)Ú_exponents_re   rf   rº   u  s    z_exponents.<locals>._exponents_)Úset)rµ   rq   rl   re   )rº   rf   Ú
_exponentsb  s    	r¼   c                s   ‡ fdd„|   t¡D ƒS )zB Find the types of functions in expr, to estimate the complexity. c                s   h | ]}ˆ |j kr|j’qS re   )rª   Úfunc)rb   Úe)rq   re   rf   ú	<setcomp>…  s    z_functions.<locals>.<setcomp>)Úatomsr   )rµ   rq   re   )rq   rf   Ú
_functionsƒ  s    rÁ   c                s<   ‡fdd„dD ƒ\‰‰‡ ‡‡‡fdd„‰ t ƒ }ˆ | |ƒ |S )ap  
    Find numbers a such that a linear substitution x -> x + a would
    (hopefully) simplify expr.

    Examples
    ========

    >>> from sympy.integrals.meijerint import _find_splitting_points as fsp
    >>> from sympy import sin
    >>> from sympy.abc import x
    >>> fsp(x, x)
    {0}
    >>> fsp((x-1)**3, x)
    {1}
    >>> fsp(sin(x+3)*x, x)
    {-3, 0}
    c                s   g | ]}t |ˆ gd ‘qS ))rm   )r   )rb   rn   )rq   re   rf   r©   š  s    z*_find_splitting_points.<locals>.<listcomp>Zpqc                st   t | tƒsd S |  ˆˆ ˆ ¡}|rL|ˆ dkrL| |ˆ  |ˆ  ¡ d S | jrVd S x| jD ]}ˆ ||ƒ q^W d S )Nr   )Ú
isinstancer   Úmatchr   Zis_Atomrj   )rµ   rl   r¶   r¹   )Úcompute_innermostr—   r˜   rq   re   rf   rÄ   œ  s    
z1_find_splitting_points.<locals>.compute_innermost)r»   )rµ   rq   Ú	innermostre   )rÄ   r—   r˜   rq   rf   Ú_find_splitting_pointsˆ  s
    
rÆ   c       	      C   sÞ   t j}t j}t j}t| ƒ} t | ¡}x®|D ]¦}||kr@||9 }q*||jkrT||9 }q*|jrÈ||jjkrÈ|j 	|¡\}}||fkr”t
|jƒ 	|¡\}}||fkrÈ|||j 9 }|tt||j ddƒ9 }q*||9 }q*W |||fS )aq  
    Split expression ``f`` into fac, po, g, where fac is a constant factor,
    po = x**s for some s independent of s, and g is "the rest".

    Examples
    ========

    >>> from sympy.integrals.meijerint import _split_mul
    >>> from sympy import sin
    >>> from sympy.abc import s, x
    >>> _split_mul((3*x)**s*sin(x**2)*x, x)
    (3**s, x*x**s, sin(x**2))
    F)rœ   )r   r¤   r   r   Ú	make_argsrª   r³   r'   r´   r±   r   r!   r"   )	rd   rq   r}   ÚpoÚgrj   r„   r¦   r”   re   re   rf   Ú
_split_mul¬  s(    






rÊ   c             C   sj   t  | ¡}g }xV|D ]N}|jrX|jjrX|j}|j}|dk rH| }d| }||g| 7 }q| |¡ qW |S )a   
    Return a list ``L`` such that ``Mul(*L) == f``.

    If ``f`` is not a ``Mul`` or ``Pow``, ``L=[f]``.
    If ``f=g**n`` for an integer ``n``, ``L=[g]*n``.
    If ``f`` is a ``Mul``, ``L`` comes from applying ``_mul_args`` to all factors of ``f``.
    r   rM   )r   rÇ   r³   r'   rp   r´   rw   )rd   rj   ÚgsrÉ   rn   r´   re   re   rf   Ú	_mul_argsÓ  s    

rÌ   c             C   sB   t | ƒ}t|ƒdk rdS t|ƒdkr.t|ƒgS dd„ t|dƒD ƒS )aŸ  
    Find all the ways to split ``f`` into a product of two terms.
    Return None on failure.

    Explanation
    ===========

    Although the order is canonical from multiset_partitions, this is
    not necessarily the best order to process the terms. For example,
    if the case of len(gs) == 2 is removed and multiset is allowed to
    sort the terms, some tests fail.

    Examples
    ========

    >>> from sympy.integrals.meijerint import _mul_as_two_parts
    >>> from sympy import sin, exp, ordered
    >>> from sympy.abc import x
    >>> list(ordered(_mul_as_two_parts(x*sin(x)*exp(x))))
    [(x, exp(x)*sin(x)), (x*exp(x), sin(x)), (x*sin(x), exp(x))]
    r   Nc             S   s    g | ]\}}t |Ž t |Ž f‘qS re   )r   )rb   rq   Úyre   re   rf   r©     s    z%_mul_as_two_parts.<locals>.<listcomp>)rÌ   Úlenr­   r]   )rd   rË   re   re   rf   Ú_mul_as_two_partsê  s    
rÏ   c          
   C   s–   dd„ }t t| jƒt| jƒ ƒ}|d| j |d   }|dt |d | j   }|t|| j|ƒ|| j	|ƒ|| j
|ƒ|| j|ƒ| j| |||   ƒfS )zO Return C, h such that h is a G function of argument z**n and
        g = C*h. c             S   s:   g }x0| D ](}x"t |ƒD ]}| || | ¡ qW q
W |S )z5 (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) )Úrangerw   )Úparamsrn   rl   r„   rc   re   re   rf   Úinflate  s
    
z_inflate_g.<locals>.inflaterM   r   )r   rÎ   rz   r|   r   r   ÚdeltarK   ry   Úaotherr{   Úbotherr¹   )rÉ   rn   rÒ   ÚvÚCre   re   rf   Ú
_inflate_g	  s    rØ   c             C   s6   dd„ }t || jƒ|| jƒ|| jƒ|| jƒd| j ƒS )zQ Turn the G function into one of inverse argument
        (i.e. G(1/x) -> G'(x)) c             S   s   dd„ | D ƒS )Nc             S   s   g | ]}d | ‘qS )rM   re   )rb   r„   re   re   rf   r©   "  s    z'_flip_g.<locals>.tr.<locals>.<listcomp>re   )Úlre   re   rf   Útr!  s    z_flip_g.<locals>.trrM   )rK   r{   rÕ   ry   rÔ   r¹   )rÉ   rÚ   re   re   rf   Ú_flip_g  s    rÛ   c                s¬   |dk rt t| ƒ| ƒS t|jƒ‰ t|jƒ}t| |ƒ\}} | j}|dt dˆ  d  ˆ tddƒ   }|ˆ ˆ   }‡ fdd„t	ˆ ƒD ƒ}|t
| j| j| jt| jƒ| |ƒfS )a\  
    Let d denote the integrand in the definition of the G function ``g``.
    Consider the function H which is defined in the same way, but with
    integrand d/Gamma(a*s) (contour conventions as usual).

    If ``a`` is rational, the function H can be written as C*G, for a constant C
    and a G-function G.

    This function returns C, G.
    r   r   rM   rŽ   c                s   g | ]}|d  ˆ  ‘qS )rM   re   )rb   rn   )r—   re   rf   r©   <  s    z"_inflate_fox_h.<locals>.<listcomp>)Ú_inflate_fox_hrÛ   r   r—   r˜   rØ   r¹   r   r   rÐ   rK   ry   rÔ   r{   r¢   rÕ   )rÉ   r„   r˜   ÚDr_   Úbsre   )r—   rf   rÜ   &  s    

&rÜ   c             K   s(   t | |f|Ž}||jkr$t| f|ŽS |S )z¶
    Return a dummy. This will return the same dummy if the same token+name is
    requested more than once, and it is not already in expr.
    This is for being cache-friendly.
    )Ú_dummy_rª   r   )ÚnameÚtokenrµ   ÚkwargsÚdre   re   rf   Ú_dummyB  s    
rä   c             K   s,   | |ft kr t| f|Žt | |f< t | |f S )z`
    Return a dummy associated to name and token. Same effect as declaring
    it globally.
    )Ú_dummiesr   )rà   rá   râ   re   re   rf   rß   N  s    rß   c                s    t ‡ fdd„|  tt¡D ƒƒ S )zŠ Check if f(x), when expressed using G functions on the positive reals,
        will in fact agree with the G functions almost everywhere c             3   s   | ]}ˆ |j kV  qd S )N)rª   )rb   rµ   )rq   re   rf   rg   \  s    z_is_analytic.<locals>.<genexpr>)ÚanyrÀ   r;   r   )rd   rq   re   )rq   rf   Ú_is_analyticY  s    rç   Tc                s
  ˆ r|   dd„ t¡} d‰ t| tƒs&| S tdtd\‰‰}tˆˆk tˆˆƒƒˆˆkftt	t
ˆƒƒtkt	t
ˆƒdt  ƒtkƒtt
ˆƒt dƒftt	dt
ˆƒ t ƒtkt	dt
ˆƒ t ƒtkƒtt
ˆƒdƒftt	dt
ˆƒ t ƒtk t	dt
ˆƒ t ƒtkƒtjftt	t
ˆƒtd  ƒtd kt	t
ˆƒtd  ƒtd kƒtt
ˆƒdƒftt	t
ˆƒtd  ƒtd kt	t
ˆƒtd  ƒtd k ƒtjftt	t
ˆd d d ƒƒtk tt	t
ˆd d d ƒƒtƒƒtjftt	t
ˆd d d ƒƒtk tdˆd d d  dƒƒtjftt	tˆƒƒtkt	ttd	t tj ƒˆ ƒƒtkƒttttj t ƒˆ ƒdƒftt	tˆƒƒtd kt	ttt tj ƒˆ ƒƒtd kƒttttj t d ƒˆ ƒdƒftˆˆktˆˆk |ƒƒˆˆkftˆd dƒˆd dk@ ˆd dkftdˆ dƒtt	t
ˆƒƒƒt	ˆƒ dk@ t	ˆƒdkftˆdƒtt	t
ˆƒƒƒt	ˆƒ dk@ t	ˆƒdkft	t
ˆƒƒtd k tt	t
ˆƒƒƒtt	ˆd ƒƒ dk@ ˆd dkfg}| jtt‡ fd
d„| jƒƒŽ } d}x|rÖd}xt|ƒD ]ú\}\}}|j| jkròqÒxÖt| jƒD ]Æ\}}	||jd jkr2|	 |jd ¡‰d}
nd}
|	 |jd ¡‰ˆsPq ‡fdd„|jd|
… |j|
d d…  D ƒ}|g‰xØ|D ]Ð}xÈt| jƒD ]º\}}|ˆkr°qš||krÆˆ|g7 ‰P t|tƒr|jd |krt|tƒr|jd |jkrˆ|g7 ‰P t|tƒrš|jd |kršt|tƒrš|jd |jkršˆ|g7 ‰P qšW qŠW tˆƒt|ƒd krxq ‡fdd„t| jƒD ƒ| ˆ¡g }tr¶|dkr¶td|ƒ | j|Ž } d}P q W qÒW q¼W ‡‡fdd„}|   dd„ |¡} trtd| ƒ | S )a®  
    Do naive simplifications on ``cond``.

    Explanation
    ===========

    Note that this routine is completely ad-hoc, simplification rules being
    added as need arises rather than following any logical pattern.

    Examples
    ========

    >>> from sympy.integrals.meijerint import _condsimp as simp
    >>> from sympy import Or, Eq
    >>> from sympy.abc import x, y
    >>> simp(Or(x < y, Eq(x, y)))
    x <= y
    c             S   s   | j S )N)Úis_Relational)Ú_re   re   rf   rr   s  rs   z_condsimp.<locals>.<lambda>Fzp q r)r†   r   r   rM   éþÿÿÿc                s
   t | ˆ ƒS )N)Ú	_condsimp)ré   )Úfirstre   rf   rr   ™  rs   Tc                s   g | ]}|  ˆ ¡‘qS re   )rœ   )rb   rq   )r¶   re   rf   r©   ©  s    z_condsimp.<locals>.<listcomp>Nc                s   g | ]\}}|ˆ kr|‘qS re   re   )rb   ÚkZarg_)Ú	otherlistre   rf   r©   ¼  s    )
r   r   r™   é   é   é   é   é   é   é   zused new rule:c                s’   | j dks| jdkr| S | j}| tˆ ƒˆ ¡}|sJ| ttˆ ƒˆ ƒ¡}|s†t|tƒr‚|j	d j
s‚|j	d tjkr‚|j	d dkS | S |ˆ  dkS )Nz==r   rM   )Zrel_opÚrhsÚlhsrÃ   r   r%   r#   rÂ   r&   rj   Zis_polarr   ÚInfinity)ÚrelZLHSr¶   )r—   r˜   re   rf   Úrel_touchupÆ  s    z_condsimp.<locals>.rel_touchupc             S   s   | j S )N)rè   )ré   re   re   rf   rr   Õ  rs   z_condsimp: ) Úreplacer   rÂ   rS   r   r   rP   r   rO   r   r   r   r   Úfalser   Útruer%   r(   r¥   r2   r/   r½   r¢   r£   rj   Ú	enumeraterª   rÃ   rÎ   rœ   r   Úprint)r~   rì   r   ÚrulesZchangeZiruleÚfroÚtorn   Zarg1ÚnumZ	otherargsÚarg2rí   Zarg3Únewargsrú   re   )rì   r¶   rî   r—   r˜   rf   rë   _  sž    
(0088:6"$"$40F
.









rë   c             C   s   t | tƒr| S t|  ¡ ƒS )z Re-evaluate the conditions. )rÂ   Úboolrë   Zdoit)r~   re   re   rf   Ú
_eval_condÚ  s    
r  Fc             C   s"   t | |ƒ}|s| t dd„ ¡}|S )zû Bring expr nearer to its principal branch by removing superfluous
        factors.
        This function does *not* guarantee to yield the principal branch,
        to avoid introducing opaque principal_branch() objects,
        unless full_pb=True. c             S   s   | S )Nre   )rq   rÍ   re   re   rf   rr   í  rs   z&_my_principal_branch.<locals>.<lambda>)r$   rû   )rµ   ÚperiodÚfull_pbrl   re   re   rf   Ú_my_principal_branchå  s    
r
  c       	         sŽ   t ||ƒ\}‰t |j|ƒ\}‰ | ¡ }t||ƒ}| tˆ ƒ|ˆd ˆ  d    }‡ ‡fdd„}|t||jƒ||jƒ||jƒ||j	ƒ|| ƒfS )z”
    Rewrite the integral fac*po*g dx, from zero to infinity, as
    integral fac*G, where G has argument a*x. Note po=x**s.
    Return fac, G.
    rM   c                s   ‡ ‡fdd„| D ƒS )Nc                s    g | ]}|d ˆ ˆ   d  ‘qS )rM   re   )rb   r„   )r“   Úsre   rf   r©     s    z1_rewrite_saxena_1.<locals>.tr.<locals>.<listcomp>re   )rÙ   )r“   r  re   rf   rÚ      s    z_rewrite_saxena_1.<locals>.tr)
r·   r¹   Ú
get_periodr
  r   rK   ry   rÔ   r{   rÕ   )	r}   rÈ   rÉ   rq   ré   r„   r  r×   rÚ   re   )r“   r  rf   Ú_rewrite_saxena_1ñ  s    
 $r  c          
   C   sÆ  | j }t| j|ƒ\}}tt| jƒt| jƒt| jƒt| jƒgƒ\}}}}	||	krˆdd„ }
t	t
|
| jƒ|
| jƒ|
| jƒ|
| jƒ|| ƒ|ƒS g }x"| jD ]}|t|ƒ dk g7 }q”W x$| jD ]}|ddt|ƒ k g7 }q¸W t|Ž }x"| jD ]}|t|ƒ dk g7 }qæW x&| jD ]}|ddt|ƒ k g7 }q
W t|Ž }t| jƒ |	d | d  |	| k}dd„ }|dƒ |d||||||	f ƒ |d	t| jƒt| jƒf ƒ |d
t| jƒt| jƒf ƒ |d|||f ƒ g }g }d|k||	k d|kg}d|kd|kt|	|d ƒttt|dƒt||d ƒƒƒg}d|kt|	|ƒg}xBtt|d ƒd ƒD ]*}|ttt|ƒƒ|d|  t ƒg7 }qFW |dktt|ƒƒ|t k g}t|dƒ|g}|r¨g }x*|||gD ]}|t|| | Ž g7 }q´W ||7 }|d|ƒ |g}|rög }tt|dƒ|d |k||	ktt|ƒƒ|t k f|žŽ g}||7 }|d|ƒ ||g}|rRg }t||	k d|k|dkttt|ƒƒ|t ƒf|žŽ g}|t||	d kt|dƒttt|ƒƒdƒf|žŽ g7 }||7 }|d|ƒ g }|t||	ƒt|dƒtt|ƒdƒt|dƒg7 }|s||g7 }g }x*t| j| jƒD ]\}}||| g7 }q W |tt|Ž ƒdk g7 }t|Ž }||g7 }|d|gƒ t|dktt|ƒƒ|t k ƒg}|s ||g7 }t|Ž }||g7 }|d|gƒ t|Ž S )aV  
    Return a condition under which the mellin transform of g exists.
    Any power of x has already been absorbed into the G function,
    so this is just $\int_0^\infty g\, dx$.

    See [L, section 5.6.1]. (Note that s=1.)

    If ``helper`` is True, only check if the MT exists at infinity, i.e. if
    $\int_1^\infty g\, dx$ exists.
    c             S   s   dd„ | D ƒS )Nc             S   s   g | ]}d | ‘qS )rM   re   )rb   rq   re   re   rf   r©     s    z4_check_antecedents_1.<locals>.tr.<locals>.<listcomp>re   )rÙ   re   re   rf   rÚ     s    z _check_antecedents_1.<locals>.trrM   r   c              W   s   t | Ž  d S )N)Ú_debug)Úmsgre   re   rf   r^   ,  s    z#_check_antecedents_1.<locals>.debugz$Checking antecedents for 1 function:z*  delta=%s, eta=%s, m=%s, n=%s, p=%s, q=%sz  ap = %s, %sz  bq = %s, %sz"  cond_3=%s, cond_3*=%s, cond_4=%sr   z	  case 1:z	  case 2:z	  case 3:z  extra case:z  second extra case:)rÓ   r·   r¹   r   rÎ   r{   ry   rz   r|   Ú_check_antecedents_1rK   rÕ   rÔ   r   rO   r   r¢   r   rR   rÐ   r*   r   r   r%   r   Úzipr   rP   )rÉ   rq   ÚhelperrÓ   Úetaré   r¶   rn   r—   r˜   rÚ   Útmpr“   r„   Zcond_3Zcond_3_starZcond_4r^   ÚcondsZcase1Ztmp1Ztmp2Ztmp3rí   Úextrar”   Zcase2Zcase3Z
case_extrar  Zcase_extra_2re   re   rf   r    s–    0$8*

*
4
,

 

r  c             C   s¬   t | j|ƒ\}}d| }x| jD ]}|t|d ƒ9 }q W x"| jD ]}|td| d ƒ9 }q@W x"| jD ]}|td| d ƒ }qdW x| jD ]}|t|d ƒ }qˆW tt|ƒƒS )aƒ  
    Evaluate $\int_0^\infty g\, dx$ using G functions,
    assuming the necessary conditions are fulfilled.

    Examples
    ========

    >>> from sympy.abc import a, b, c, d, x, y
    >>> from sympy import meijerg
    >>> from sympy.integrals.meijerint import _int0oo_1
    >>> _int0oo_1(meijerg([a], [b], [c], [d], x*y), x)
    gamma(-a)*gamma(c + 1)/(y*gamma(-d)*gamma(b + 1))
    rM   )	r·   r¹   r{   rI   ry   rÕ   rÔ   rX   r!   )rÉ   rq   r  ré   rl   r“   r„   re   re   rf   Ú	_int0oo_1y  s    r  c                s¨  ‡‡fdd„}t |ˆƒ\}}t |jˆƒ\}}	t |jˆƒ\}}
|	dk dkrV|	 }	t|ƒ}|
dk dkrp|
 }
t|ƒ}|	jr||
js€dS |	j|	j }}|
j|
j }}t|| || ƒ}|||  }|||  }t||ƒ\}}t||ƒ\}}||ƒ}||ƒ}| || 9 } t |jˆƒ\}}t |jˆƒ\}}|d | d ‰ | t|ƒ|ˆ    } ‡ fdd„}t	||j
ƒ||jƒ||jƒ||jƒ|ˆ ƒ}t	|j
|j|j|j|ˆ ƒ}t| dd	||fS )
aá  
    Rewrite the integral ``fac*po*g1*g2`` from 0 to oo in terms of G
    functions with argument ``c*x``.

    Explanation
    ===========

    Return C, f1, f2 such that integral C f1 f2 from 0 to infinity equals
    integral fac ``po``, ``g1``, ``g2`` from 0 to infinity.

    Examples
    ========

    >>> from sympy.integrals.meijerint import _rewrite_saxena
    >>> from sympy.abc import s, t, m
    >>> from sympy import meijerg
    >>> g1 = meijerg([], [], [0], [], s*t)
    >>> g2 = meijerg([], [], [m/2], [-m/2], t**2/4)
    >>> r = _rewrite_saxena(1, t**0, g1, g2, t)
    >>> r[0]
    s/(4*sqrt(pi))
    >>> r[1]
    meijerg(((), ()), ((-1/2, 0), ()), s**2*t/4)
    >>> r[2]
    meijerg(((), ()), ((m/2,), (-m/2,)), t/4)
    c          	      s@   t | jˆƒ\}}|  ¡ }t| j| j| j| jt||ˆ ƒˆ|  ƒS )N)	r·   r¹   r  rK   ry   rÔ   r{   rÕ   r
  )rÉ   r„   r“   Zper)r	  rq   re   rf   Úpb±  s    z_rewrite_saxena.<locals>.pbr   TNrM   c                s   ‡ fdd„| D ƒS )Nc                s   g | ]}|ˆ  ‘qS re   re   )rb   r„   )r'   re   rf   r©   ×  s    z/_rewrite_saxena.<locals>.tr.<locals>.<listcomp>re   )rÙ   )r'   re   rf   rÚ   Ö  s    z_rewrite_saxena.<locals>.tr)Úpolar)r·   r¹   rÛ   Úis_Rationalr—   r˜   r   rØ   r   rK   ry   rÔ   r{   rÕ   rZ   )r}   rÈ   Úg1Úg2rq   r	  r  ré   r  Úb1Úb2Úm1Zn1Úm2Zn2ÚtauÚr1Úr2ÚC1ÚC2Úa1r“   Úa2rÚ   re   )r'   r	  rq   rf   Ú_rewrite_saxena–  s<    ,r(  c       +         s0  t ˆj|ƒ\‰	}t ˆj|ƒ\‰}ttˆjƒtˆjƒtˆjƒtˆjƒgƒ\}}‰‰ttˆjƒtˆjƒtˆjƒtˆjƒgƒ\}}‰‰|| ˆˆ d  }|| ˆˆ d  }	ˆjˆˆ d  d ‰ˆjˆˆ d  d ‰ˆˆ ˆˆ  }
dˆˆ  ˆ ˆ }t	ˆ| |  t
tˆƒƒ ˆˆ  ‰t	ˆ| |  t
tˆ	ƒƒ ˆˆ  ‰
tdƒ tdˆ	||ˆˆ|ˆf ƒ tdˆ||ˆˆ|	ˆf ƒ td|
|ˆˆ
f ƒ ‡‡fdd„}|ƒ }t‡fd	d
„ˆjD ƒŽ }t‡fdd
„ˆjD ƒŽ }t‡‡‡fdd
„ˆjD ƒŽ }t‡‡‡fdd
„ˆjD ƒŽ }t‡‡‡fdd
„ˆjD ƒŽ }t‡‡‡fdd
„ˆjD ƒŽ }t
|
ƒdtˆd ˆˆ  ˆˆ ˆˆ   ˆd ˆˆ   ƒ  dk}t
|
ƒdtˆd ˆˆ  ˆˆ ˆˆ   ˆd ˆˆ   ƒ  dk}t
tˆ	ƒƒ|t	 k }tt
tˆ	ƒƒ|t	 ƒ}t
tˆƒƒ|	t	 k }tt
tˆƒƒ|	t	 ƒ}t||	  t	 tj ƒ}t|ˆ ˆ	 ƒ}t|ˆ	 ˆ ƒ}|d| kr¸tt|
dƒ||	 dktt|dƒtˆˆ ˆ ˆ ƒdk tˆˆ ˆ ˆ ƒdk ƒƒ}nºdd„ }tt|
dƒ|d |	 dkttt|dƒ||ƒƒttˆˆ ˆ ˆ ƒdk t|dƒƒƒƒ}tt|
dƒ|	d | dkttt|dƒ||ƒƒttˆˆ ˆ ˆ ƒdk t|dƒƒƒƒ}t||ƒ}y¤ˆˆ t
ˆƒdˆˆ    tˆƒ ˆˆ t
ˆ	ƒdˆˆ    tˆ
ƒ  } t| dkƒdkrÜ| dk}!n:‡‡‡‡‡	‡
‡‡fdd„}"t|"ddƒ|"ddƒ tttˆ	ƒdƒttˆƒdƒƒf|"ttˆƒƒdƒ|"ttˆƒƒdƒ tttˆ	ƒdƒttˆƒdƒƒf|"dttˆ	ƒƒƒ|"dttˆ	ƒƒƒ tttˆ	ƒdƒttˆƒdƒƒf|"ttˆƒƒttˆ	ƒƒƒdfƒ}#| dktt| dƒt|#dƒt|ƒdkƒtt| dƒt|#dƒt|ƒdkƒg}$t|$Ž }!W n tk
r2   d}!Y nX xz|df|df|df|df|df|df|df|df|df|df|d f|d!f|d"f|d#f|!d$fgD ]\}%}&td%|& |%ƒ q”W g ‰ ‡ fd&d'„}'ˆ t|| | | dk|jdk|	jdk|||||ƒg7 ‰ |'dƒ ˆ ttˆˆƒt|dƒ|	jdkˆ	jdktˆƒdk ||||ƒ	g7 ‰ |'dƒ ˆ ttˆˆƒt|	dƒ|jdkˆjdktˆƒdk ||||ƒ	g7 ‰ |'dƒ ˆ ttˆˆƒtˆˆƒt|dƒt|	dƒˆ	jdkˆjdktˆƒdk tˆƒdk tˆ	ˆƒ|||ƒg7 ‰ |'dƒ ˆ ttˆˆƒtˆˆƒt|dƒt|	dƒˆ	jdkˆjdktˆˆ ƒdk tˆˆ	ƒ|||ƒg7 ‰ |'dƒ ˆ tˆˆk|jdk|jdk|	dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆk |jdk|jdk|	dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆk|jdk|	jdk|dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆk |jdk|	jdk|dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆktˆˆƒt|dƒ|	dkˆ	jdktˆƒdk |||||ƒg7 ‰ |'dƒ ˆ tˆˆk tˆˆƒt|dƒ|	dkˆ	jdktˆƒdk |||||ƒg7 ‰ |'d ƒ ˆ ttˆˆƒˆˆk|dkt|	dƒˆjdktˆƒdk |||||ƒg7 ‰ |'d!ƒ ˆ ttˆˆƒˆˆk |dkt|	dƒˆjdktˆƒdk |||||ƒg7 ‰ |'d"ƒ ˆ tˆˆk ˆˆk|dk|	dk|||||||ƒg7 ‰ |'d#ƒ ˆ tˆˆkˆˆk |dk|	dk|||||||ƒg7 ‰ |'d$ƒ ˆ tˆˆkˆˆk|dk|	dk|||||||||ƒg7 ‰ |'d(ƒ ˆ tˆˆk ˆˆk |dk|	dk|||||||||ƒg7 ‰ |'d)ƒ ˆ tt|dƒ|jdk|jdk|
jdk|||ƒg7 ‰ |'d*ƒ ˆ tt|dƒ|jdk|jdk|
jdk|||ƒg7 ‰ |'d+ƒ ˆ tt|dƒ|jdk|	jdk|
jdk|||ƒg7 ‰ |'d,ƒ ˆ tt|dƒ|jdk|	jdk|
jdk|||ƒg7 ‰ |'d-ƒ ˆ tt|| dƒ|jdk|	jdk|||||ƒg7 ‰ |'d.ƒ ˆ tt|| dƒ|jdk|	jdk|||||ƒg7 ‰ |'d/ƒ tˆ|dd0}(tˆ|dd0})ˆ t|)t|dƒˆ|k |jdk||||ƒg7 ‰ |'d1ƒ ˆ t|)t|dƒˆ|k |jdk||||ƒg7 ‰ |'d2ƒ ˆ t|(t|dƒˆ|k |	jdk||||ƒg7 ‰ |'d3ƒ ˆ t|(t|dƒˆ|k |	jdk||||ƒg7 ‰ |'d4ƒ tˆ Ž }*t|*ƒdkrÄ|*S ˆ t|| ˆkt|dƒt|
dƒ|jdk|jdk|	jdkt
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d5ƒ ˆ t|| ˆkt|dƒt|
dƒ|jdk|jdk|	jdkt
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d6ƒ ˆ ttˆˆd ƒt|dƒt|
dƒ|jdk|jdk|	dk|	t	 t
tˆƒƒk |||||!ƒg7 ‰ |'d7ƒ ˆ ttˆˆd ƒt|dƒt|
dƒ|jdk|jdk|	dk|	t	 t
tˆƒƒk |||||!ƒg7 ‰ |'d8ƒ ˆ tˆˆd k t|dƒt|
dƒ|jdk|jdk|	dk|	t	 t
tˆƒƒk t
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d9ƒ ˆ tˆˆd kt|dƒt|
dƒ|jdk|jdk|	dk|	t	 t
tˆƒƒk t
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d:ƒ ˆ tt|dƒt|
dƒ|| dk|jdk|	jdk|jdkt
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d;ƒ ˆ tt|dƒt|
dƒ|| ˆk|jdk|	jdk|jdkt
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d<ƒ ˆ tt|dƒt|
dƒtˆˆd ƒ|jdk|	jdk|dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|d t	 k |||||!ƒg7 ‰ |'d=ƒ ˆ tt|dƒt|
dƒtˆˆd ƒ|jdk|	jdk|dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|d t	 k |||||!ƒg7 ‰ |'d>ƒ ˆ tt|dƒt|
dƒˆˆd k |jdk|	jdk|dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d?ƒ ˆ tt|dƒt|
dƒˆˆd k|jdk|	jdk|dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d@ƒ tˆ Ž S )Az> Return a condition under which the integral theorem applies. r   rM   zChecking antecedents:z1  sigma=%s, s=%s, t=%s, u=%s, v=%s, b*=%s, rho=%sz1  omega=%s, m=%s, n=%s, p=%s, q=%s, c*=%s, mu=%s,z"  phi=%s, eta=%s, psi=%s, theta=%sc                 sN   xHˆ ˆgD ]<} x6| j D ],}x&| jD ]}|| }|jr"|jr"dS q"W qW q
W dS )NFT)ry   r{   Ú
is_integerÚis_positive)rÉ   rc   ÚjÚdiff)r  r  re   rf   Ú_c1ÿ  s    z_check_antecedents.<locals>._c1c                s,   g | ]$}ˆ j D ]}td | | ƒdk‘qqS )rM   r   )r{   r   )rb   rc   r+  )r  re   rf   r©     s    z&_check_antecedents.<locals>.<listcomp>c                s,   g | ]$}ˆ j D ]}td | | ƒdk ‘qqS )rM   r   )ry   r   )rb   rc   r+  )r  re   rf   r©   	  s    c                s6   g | ].}ˆˆ t d | d  ƒ t ˆ ƒ tddƒk‘qS )rM   éýÿÿÿr   )r   r   )rb   rc   )Úmur—   r˜   re   rf   r©   
  s    c                s2   g | ]*}ˆˆ t d | ƒ t ˆ ƒ tddƒk‘qS )rM   r.  r   )r   r   )rb   rc   )r/  r—   r˜   re   rf   r©     s    c                s6   g | ].}ˆˆ t d | d  ƒ t ˆ ƒ tddƒk‘qS )rM   r.  r   )r   r   )rb   rc   )ÚrhoÚurÖ   re   rf   r©     s    c                s2   g | ]*}ˆˆ t d | ƒ t ˆ ƒ tddƒk‘qS )rM   r.  r   )r   r   )rb   rc   )r0  r1  rÖ   re   rf   r©     s    r   c             S   s   | dkot td|  ƒƒtk S )aã  Returns True if abs(arg(1-z)) < pi, avoiding arg(0).

            Explanation
            ===========

            If ``z`` is 1 then arg is NaN. This raises a
            TypeError on `NaN < pi`. Previously this gave `False` so
            this behavior has been hardcoded here but someone should
            check if this NaN is more serious! This NaN is triggered by
            test_meijerint() in test_meijerint.py:
            `meijerint_definite(exp(x), x, 0, I)`
            rM   )r   r   r   )r_   re   re   rf   Ú_cond*  s    z!_check_antecedents.<locals>._condFc                sP   | ˆˆ  t ˆ ƒdˆˆ    tˆƒ |ˆˆ  t ˆƒdˆˆ    tˆƒ  S )NrM   )r   r3   )Úc1Úc2)Úomegar—   Úpsir˜   ÚsigmaÚthetar1  rÖ   re   rf   Ú	lambda_s0Y  s    &z%_check_antecedents.<locals>.lambda_s0rŽ   Trš   r™   rï   rð   rñ   é   é	   é
   rò   ró   rô   rõ   é   z  c%s:c                s   t d|  ˆ d ƒ d S )Nz
  case %s:rŽ   )r  )Úcount)r  re   rf   Úprr  s    z_check_antecedents.<locals>.prr¡   é   é   é   é   é   é   é   )r  ZE1ZE2ZE3ZE4é   é   é   é   é   é   é   é   é    é!   é"   é#   )r·   r¹   r   rÎ   r{   ry   rz   r|   r   r   r   r%   r  rO   r   r   r'   r¥   r!   rP   r   r2   r  r0   r    Ú	TypeErrorr*  Zis_negativer  )+r  r  rq   ré   r  r”   r¶   rn   ZbstarZcstarÚphir  r-  r3  r4  Úc3Zc4Zc5Zc6Zc7Zc8Zc9Zc10Zc11Zc12Zc13Zz0ZzosZzsoZc14r2  Zc14_altZlambda_cZc15r9  Zlambda_sr  r~   rc   r?  Z
mt1_existsZ
mt2_existsr   re   )r  r  r  r/  r5  r—   r6  r˜   r0  r7  r8  r1  rÖ   rf   Ú_check_antecedentsÞ  sª   00$$** ((	

"&"" "
&$.
..$$$    ((((2222  ,,,,6600.0660000rV  c             C   s   t | j|ƒ\}}t |j|ƒ\}}dd„ }|| jƒt|jƒ }t|jƒ|| jƒ }|| jƒt|jƒ }	t|jƒ|| jƒ }
t|||	|
|| ƒ| S )aà  
    Express integral from zero to infinity g1*g2 using a G function,
    assuming the necessary conditions are fulfilled.

    Examples
    ========

    >>> from sympy.integrals.meijerint import _int0oo
    >>> from sympy.abc import s, t, m
    >>> from sympy import meijerg, S
    >>> g1 = meijerg([], [], [-S(1)/2, 0], [], s**2*t/4)
    >>> g2 = meijerg([], [], [m/2], [-m/2], t/4)
    >>> _int0oo(g1, g2, t)
    4*meijerg(((1/2, 0), ()), ((m/2,), (-m/2,)), s**(-2))/s**2
    c             S   s   dd„ | D ƒS )Nc             S   s   g | ]
}| ‘qS re   re   )rb   rq   re   re   rf   r©   $  s    z(_int0oo.<locals>.neg.<locals>.<listcomp>re   )rÙ   re   re   rf   Úneg#  s    z_int0oo.<locals>.neg)r·   r¹   r{   r¢   ry   rÔ   rÕ   rK   )r  r  rq   r  ré   r5  rW  r&  r'  r  r  re   re   rf   Ú_int0oo  s    rX  c                sn   t ||ƒ\}‰t |j|ƒ\}‰ ‡ ‡fdd„}t| |ˆˆ    ddt||jƒ||jƒ||jƒ||jƒ|jƒfS )z Absorb ``po`` == x**s into g. c                s   ‡ ‡fdd„| D ƒS )Nc                s   g | ]}|ˆˆ   ‘qS re   re   )rb   r”   )r“   r  re   rf   r©   2  s    z2_rewrite_inversion.<locals>.tr.<locals>.<listcomp>re   )rÙ   )r“   r  re   rf   rÚ   1  s    z_rewrite_inversion.<locals>.trT)r  )r·   r¹   rZ   rK   ry   rÔ   r{   rÕ   )r}   rÈ   rÉ   rq   ré   r„   rÚ   re   )r“   r  rf   Ú_rewrite_inversion,  s
    rY  c                sV  t dƒ ˆ j‰tˆˆƒ\}}|dk r:t dƒ ttˆ ƒˆƒS ‡fdd„‰‡fdd„‰ttˆ jƒtˆ jƒtˆ j	ƒtˆ j
ƒgƒ\}}}}|| | }|| | }	||	 d }
|| ‰ˆd	kr¾tj}nˆd	krÌd	}ntj}d	ˆ d tˆ j
Ž  tˆ j	Ž  ˆ ‰ˆ j}t d
||||||	|
ˆf ƒ t d|ˆ|f ƒ ˆ j|d ksZ|d	krN||ksZt dƒ dS xDˆ jD ]:}x2ˆ jD ](}|| jrn||krnt dƒ dS qnW qbW ||krÌt dƒ t‡‡fdd„ˆ jD ƒŽ S ‡ ‡fdd„}‡‡‡fdd„}‡‡‡fdd„}‡‡‡fdd„}g }|td	|kd	|k|
t | td k|dk|ˆttjt |	d	  ƒ ƒƒg7 }|t|d	 |k|d	 |k|dk|td k |dk|| d	 t | td k|ˆttjt ||  ƒ ƒ|ˆttj t ||  ƒ ƒƒg7 }|t||k|dk|dkˆ| t | td k|ˆƒƒg7 }|ttt||d kd	|k|ˆd kƒt|d	 || k|| || d kƒƒ|dk|td k |d	 t | td k|ˆttjt |	 ƒ ƒ|ˆttj t |	 ƒ ƒƒg7 }|td	|k|
dk|dk||
t  td k || t | td k|ˆttjt |	 ƒ ƒ|ˆttj t |	 ƒ ƒƒg7 }||dkg7 }t|Ž S )z7 Check antecedents for the laplace inversion integral. z#Checking antecedents for inversion:r   z  Flipping G.c                s   t |ˆ ƒ\}}| |9 } ||| 9 }||9 }g }|ttjt|ƒ t d ƒ }|ttj t|ƒ t d ƒ }	|rv|}
n|	}
|ttt|dƒt|ƒdkƒt| ƒdkƒg7 }|tt	|dƒtt
|ƒdƒt|ƒdkt|
ƒdk ƒg7 }|tt	|dƒtt
|ƒdƒt|ƒdkt|
ƒdkt| ƒdkƒg7 }t|Ž S )Nr   r   rŽ   )r·   r'   r   r¥   r   r   rO   rP   r   r   r   )r„   r“   r¦   r_   ÚplusÚcoeffÚexponentr  ZwpZwmÚw)rq   re   rf   Ústatement_halfA  s     ,4,z4_check_antecedents_inversion.<locals>.statement_halfc                s"   t ˆ | |||dƒˆ | |||dƒƒS )zW Provide a convergence statement for z**a * exp(b*z**c),
             c/f sphinx docs. TF)rO   )r„   r“   r¦   r_   )r^  re   rf   Ú	statementS  s    z/_check_antecedents_inversion.<locals>.statementr   rM   z9  m=%s, n=%s, p=%s, q=%s, tau=%s, nu=%s, rho=%s, sigma=%sz   epsilon=%s, theta=%s, delta=%sz-  Computation not valid for these parameters.Fz  Not a valid G function.z$  Using asymptotic Slater expansion.c                s   g | ]}ˆ |d  ddˆƒ‘qS )rM   r   re   )rb   r„   )r_  r_   re   rf   r©   ‚  s    z0_check_antecedents_inversion.<locals>.<listcomp>c                s   t ‡‡ fdd„ˆjD ƒŽ S )Nc                s   g | ]}ˆ |d  ddˆƒ‘qS )rM   r   re   )rb   r„   )r_  r_   re   rf   r©   …  s    z;_check_antecedents_inversion.<locals>.E.<locals>.<listcomp>)rO   ry   )r_   )rÉ   r_  )r_   rf   ÚE„  s    z'_check_antecedents_inversion.<locals>.Ec                s   ˆˆˆ  dˆ  | ƒS )NrM   re   )r_   )r7  r_  r8  re   rf   ÚH‡  s    z'_check_antecedents_inversion.<locals>.Hc                s   ˆˆˆ  dˆ  | dƒS )NrM   Tre   )r_   )r7  r^  r8  re   rf   ÚHpŠ  s    z(_check_antecedents_inversion.<locals>.Hpc                s   ˆˆˆ  dˆ  | dƒS )NrM   Fre   )r_   )r7  r^  r8  re   rf   ÚHm  s    z(_check_antecedents_inversion.<locals>.Hm)r  r¹   r·   Ú_check_antecedents_inversionrÛ   r   rÎ   r{   ry   rz   r|   r–   ÚNaNr   rÓ   r)  rO   r   r'   r¥   rP   )rÉ   rq   ré   r¾   r¶   rn   r—   r˜   r!  r   r0  ÚepsilonrÓ   r„   r“   r`  ra  rb  rc  r  re   )rÉ   r7  r_  r^  r8  rq   r_   rf   rd  7  st    0$$	
($.&$$&&"("rd  c          	   C   sH   t | j|ƒ\}}tt| j| j| j| j|||  ƒ| ƒ\}} || |  S )zO
    Compute the laplace inversion integral, assuming the formula applies.
    )r·   r¹   rÜ   rK   ry   rÔ   r{   rÕ   )rÉ   rq   r”   r“   r„   r×   re   re   rf   Ú_int_inversion²  s    ,rg  Nc                 sN  ddl m}m‰m}m‰  ts(i attƒ t| tƒr²t	| j
|ƒ |¡\}}t|ƒdkrXdS |d }|jr~|j|ksx|jjsŠdS n||krŠdS ddt| j| j| j| j|| ƒfgdfS | }|  |t¡} t| tƒ}|tkrrt| }	x|	D ]†\}
}}}| j|
dd}|ræi }x.| ¡ D ]"\}}tt|dddd||< qW |}t|tƒsT| |¡}|d	kr`qæt|ttfƒs~t| |¡ƒ}t|ƒd	krŽqæt|tƒs¢||ƒ}g }xº|D ]²\}}t t| |¡ t|¡dd|ƒ}y| |¡ t|¡}W n t!k
r   w¬Y nX t"||f Ž  #t$j%t$j&t$j'¡r*q¬t|j|j|j|jt|j
ddƒ}| (||f ¡ q¬W |ræ||fS qæW |s|dS t)d
ƒ ‡ ‡fdd„}|} t*dd| ƒ}dd„ }y,|| |||d	dd\}}}|||||ƒ}W n |k
rð   d}Y nX |dkrzt+ddƒ}|| j,krzt-| |ƒrzy@||  ||| ¡|||dd	d\}}}|||||ƒ |d¡}W n |k
rx   d}Y nX |dksš| #t$j%t$j.t$j&¡r¦t)dƒ dS t/ 0|¡}g }x†|D ]~} |  |¡\}}t|ƒdkrât1dƒ‚|d }t |j
|ƒ\}}||dt|j|j|j|jtt|dddd||  ƒfg7 }qºW t)d|ƒ |dfS )aH  
    Try to rewrite f as a sum of single G functions of the form
    C*x**s*G(a*x**b), where b is a rational number and C is independent of x.
    We guarantee that result.argument.as_coeff_mul(x) returns (a, (x**b,))
    or (a, ()).
    Returns a list of tuples (C, s, G) and a condition cond.
    Returns None on failure.
    rM   )Úmellin_transformÚinverse_mellin_transformÚIntegralTransformErrorÚMellinTransformStripErrorNr   T)Úold)Zlift)Zexponents_onlyFz)Trying recursive Mellin transform method.c                sJ   yˆ| |||dddS  ˆ k
rD   ˆt tt| ƒƒƒ|||dddS X dS )zÔ Calling simplify() all the time is slow and not helpful, since
            most of the time it only factors things in a way that has to be
            un-done anyway. But sometimes it can remove apparent poles. T)Z
as_meijergÚneedevalN)r\   rT   r
   )ÚFr  rq   Ústrip)rk  ri  re   rf   Úmy_imt  s    

z_rewrite_single.<locals>.my_imtr  zrewrite-singlec             S   sd   t | |dd}|d k	rP|\}}tt|ddƒ}t||ft| |tjtjfƒdfƒS t| |tjtjfƒS )NT)Úonly_doubleZnonrepsmall)Zrewrite)Ú_meijerint_definite_4Ú_my_unpolarifyrY   r0   rN   r   r²   rø   )rd   rq   r   rl   r~   re   re   rf   Úmy_integrator   s    z&_rewrite_single.<locals>.my_integrator)Ú
integratorr\   rm  r„   )ru  rm  r\   z"Recursive Mellin transform failed.zUnexpected form...z"Recursive Mellin transform worked:)2Ú
transformsrh  ri  rj  rk  Ú_lookup_tabler§   rÂ   rK   rU   r¹   r±   rÎ   r³   r´   r'   r  ry   rÔ   r{   rÕ   rœ   r_   rv   rÃ   Úitemsr!   r"   r  rQ   r  r¢   r·   Ú
ValueErrorr   rk   r   rø   ÚComplexInfinityÚNegativeInfinityrw   r  rä   rß   rª   rç   re  r   rÇ   ÚNotImplementedError) rd   rq   Ú	recursiverh  rj  r[  r¶   Úf_r”   rÙ   rx   Ztermsr~   r   rœ   Zsubs_r  r  rl   r}   rÉ   r"  rp  r  rt  rn  ro  ré   r„   rj   r¦   r“   re   )rk  ri  rf   Ú_rewrite_singleÂ  sº    
(




 




 


r  c             C   s8   t | |ƒ\}}}t|||ƒ}|r4|||d |d fS dS )zÿ
    Try to rewrite ``f`` using a (sum of) single G functions with argument a*x**b.
    Return fac, po, g such that f = fac*po*g, fac is independent of ``x``.
    and po = x**s.
    Here g is a result from _rewrite_single.
    Return None on failure.
    r   rM   N)rÊ   r  )rd   rq   r}  r}   rÈ   rÉ   re   re   rf   Ú	_rewrite1N  s    r€  c                sÞ   t | ˆ ƒ\}}}t‡ fdd„t|ƒD ƒƒr.dS t|ƒ}|s>dS tt|‡ fdd„‡ fdd„‡ fdd„gƒƒ}xndD ]f}x`|D ]X\}}t|ˆ |ƒ}	t|ˆ |ƒ}
|	rz|
rzt|	d	 |
d	 ƒ}|d
krz|||	d |
d |fS qzW qpW dS )a  
    Try to rewrite ``f`` as a product of two G functions of arguments a*x**b.
    Return fac, po, g1, g2 such that f = fac*po*g1*g2, where fac is
    independent of x and po is x**s.
    Here g1 and g2 are results of _rewrite_single.
    Returns None on failure.
    c             3   s   | ]}t |ˆ d ƒdkV  qdS )FN)r  )rb   rµ   )rq   re   rf   rg   e  s    z_rewrite2.<locals>.<genexpr>Nc                s&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS )Nr   rM   )ÚmaxrÎ   r¼   )r—   )rq   re   rf   rr   k  rs   z_rewrite2.<locals>.<lambda>c                s&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS )Nr   rM   )r  rÎ   rÁ   )r—   )rq   re   rf   rr   l  rs   c                s&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS )Nr   rM   )r  rÎ   rÆ   )r—   )rq   re   rf   rr   m  s   )FTrM   Fr   )rÊ   ræ   rÌ   rÏ   r¢   r   r  rO   )rd   rq   r}   rÈ   rÉ   rÙ   r}  Zfac1Zfac2r  r  r~   re   )rq   rf   Ú	_rewrite2\  s$    


r‚  c             C   sÐ   g }xjt t| |ƒtjhB tdD ]L}t|  ||| ¡|ƒ}|s@q | ||| ¡}t|tt	ƒrh| 
|¡ q |S q W |  t¡r¼tdƒ tt| ƒ|ƒ}|r¼t|tƒs²tt|ƒ| t¡ƒS | |¡ |rÌtt|ƒƒS dS )a#  
    Compute an indefinite integral of ``f`` by rewriting it as a G function.

    Examples
    ========

    >>> from sympy.integrals.meijerint import meijerint_indefinite
    >>> from sympy import sin
    >>> from sympy.abc import x
    >>> meijerint_indefinite(sin(x), x)
    -cos(x)
    )Úkeyz*Try rewriting hyperbolics in terms of exp.N)ÚsortedrÆ   r   r²   r   Ú_meijerint_indefinite_1rœ   ra   rJ   rK   rw   rk   r.   r  Úmeijerint_indefiniter-   rÂ   r¢   rW   r	   rÀ   r'   ÚextendÚnextr   )rd   rq   Úresultsr„   rl   Úrvre   re   rf   r†  z  s&     


r†  c                s2  t d| dˆƒ t| ˆƒ}|dkr$dS |\}}}}t d|ƒ tj}xb|D ]X\}}	}
t|
jˆƒ\}}t|ˆƒ\}}||	7 }|| ||d| |    }|d | d ‰ tddtjƒ}‡ fdd	„}td
d„ ||
j	ƒD ƒƒrt
||
jƒ||
jƒdg ||
j	ƒdg ||
jƒ|ƒ }n4t
||
jƒdg ||
jƒ||
j	ƒ||
jƒdg |ƒ}|jrn|  ˆd¡ tjtj¡snd}nd}t| ||ˆ|  ¡|d}|t|| dd7 }qHW ‡fdd„}t|dd}|jr
g }x.|jD ]$\}}t||ƒƒ}|||fg7 }qÒW t|ddiŽ}nt||ƒƒ}t|t|ƒft| ˆƒdfƒS )z0 Helper that does not attempt any substitution. z,Trying to compute the indefinite integral ofZwrtNz could rewrite:rM   r”   zmeijerint-indefinitec                s   ‡ fdd„| D ƒS )Nc                s   g | ]}|ˆ  d  ‘qS )rM   re   )rb   r„   )r0  re   rf   r©   ½  s    z7_meijerint_indefinite_1.<locals>.tr.<locals>.<listcomp>re   )r—   )r0  re   rf   rÚ   ¼  s    z#_meijerint_indefinite_1.<locals>.trc             s   s    | ]}|j o|d kdkV  qdS )r   TN)r)  )rb   r“   re   re   rf   rg   ¾  s    z*_meijerint_indefinite_1.<locals>.<genexpr>r   )ÚplaceT)r  c                s$   t t| ƒdd} t |  ˆ ¡d ¡S )aÀ  This multiplies out superfluous powers of x we created, and chops off
        constants:

            >> _clean(x*(exp(x)/x - 1/x) + 3)
            exp(x)

        cancel is used before mul_expand since it is possible for an
        expression to have an additive constant that doesn't become isolated
        with simple expansion. Such a situation was identified in issue 6369:

        Examples
        ========

        >>> from sympy import sqrt, cancel
        >>> from sympy.abc import x
        >>> a = sqrt(2*x + 1)
        >>> bad = (3*x*a**5 + 2*x - a**5 + 1)/a**2
        >>> bad.expand().as_independent(x)[0]
        0
        >>> cancel(bad).expand().as_independent(x)[0]
        1
        F)ÚdeeprM   )r   rT   r   Z
_from_argsZas_coeff_add)rl   )rq   re   rf   Ú_cleanÐ  s    z'_meijerint_indefinite_1.<locals>._clean)ÚevaluaterŽ  F)r  r€  r   r²   r·   r¹   rä   r¤   ræ   r{   rK   ry   rÔ   rÕ   Zis_extended_nonnegativerœ   rk   re  rz  rY   rZ   r1   r`   rj   rs  r0   rN   )rd   rq   rË   r}   rÈ   Úglr~   rl   r×   r  rÉ   r„   r“   ré   r¦   Zfac_r”   rÚ   r   r‹  r  r  r¾   re   )r0  rq   rf   r…    sF    


62"r…  c             C   sì  t d| d|||f ƒ |  t¡r,t dƒ dS |  t¡rBt dƒ dS | |||f\}}}}tdƒ}|  ||¡} |}||kr€tjdfS g }	|tjkr´|tj	k	r´t
|  || ¡|| | ƒS |tjkr°t dƒ t| |ƒ}
t d	|
ƒ xÎt|
tdd
tjg D ]´}t d|ƒ |jst dƒ qôt|  ||| ¡|ƒ}|dkr>t dƒ qôt|  ||| ¡|ƒ}|dkrht dƒ qô|\}}|\}}tt||ƒƒ}|dkršt dƒ qô|| }||fS W n¶|tj	krÞt
| ||tj	ƒ}|d  |d fS ||ftjtj	fkr(t| |ƒ}|rft|d tƒr |	 |¡ n|S n>|tj	kr´x~t| |ƒD ]p}|| dkdkr@t d| ƒ t|  ||| ¡t|| | ƒ |ƒ}|r@t|d tƒrª|	 |¡ n|S q@W |  ||| ¡} || }d}|tj	k	r ttjt|ƒ ƒ}t|ƒ}|  ||| ¡} | t|| ƒ| 9 } tj	}t d||ƒ t d| ƒ t| |ƒ}|rft|d tƒrb|	 |¡ n|S | t¡rÖt dƒ t
t|ƒ|||ƒ}|rÖt|tƒsÌtt|d ƒ|d   t¡ƒf|dd…  }|S |	 !|¡ |	rèt"t#|	ƒƒS dS )aà  
    Integrate ``f`` over the interval [``a``, ``b``], by rewriting it as a product
    of two G functions, or as a single G function.

    Return res, cond, where cond are convergence conditions.

    Examples
    ========

    >>> from sympy.integrals.meijerint import meijerint_definite
    >>> from sympy import exp, oo
    >>> from sympy.abc import x
    >>> meijerint_definite(exp(-x**2), x, -oo, oo)
    (sqrt(pi), True)

    This function is implemented as a succession of functions
    meijerint_definite, _meijerint_definite_2, _meijerint_definite_3,
    _meijerint_definite_4. Each function in the list calls the next one
    (presumably) several times. This means that calling meijerint_definite
    can be very costly.
    ÚIntegratingzwrt %s from %s to %s.z+Integrand has DiracDelta terms - giving up.Nz5Integrand has Singularity Function terms - giving up.rq   Tz  Integrating -oo to +oo.z  Sensible splitting points:)rƒ  Úreversez  Trying to split atz  Non-real splitting point.z'  But could not compute first integral.z(  But could not compute second integral.Fz)  But combined condition is always false.r   rM   zTrying x -> x + %szChanged limits tozChanged function toz*Try rewriting hyperbolics in terms of exp.)$r  rk   r:   rL   r   rœ   r   r²   r{  rø   Úmeijerint_definiterÆ   r„  r   Zis_extended_realÚ_meijerint_definite_2rë   rO   ra   rK   rw   r;   r'   r¥   r   r   r.   r-   rÂ   r¢   rW   r	   rÀ   r‡  rˆ  r   )rd   rq   r„   r“   r~  Zx_Za_Zb_rã   r‰  rÅ   r¦   Zres1Zres2Zcond1Zcond2r~   rl   ÚsplitrT  rŠ  re   re   rf   r’  ö  s®    












*
r’  c             C   sÜ   | dfg}|d d }|h}t |ƒ}||krD||dfg7 }| |¡ t|ƒ}||krl||dfg7 }| |¡ | tt¡r¤t t|ƒƒ}||kr¤||dfg7 }| |¡ | tt¡rØt	|ƒ}||krØ||dfg7 }| |¡ |S )z6 Try to guess sensible rewritings for integrand f(x). zoriginal integrandrŽ   r   r   r
   zexpand_trig, expand_mulztrig power reduction)
r   r   r
   rk   r5   r.   r   r2   r3   rV   )rd   rq   rl   ÚorigZsawÚexpandedZreducedre   re   rf   Ú_guess_expansion€  s,    




r—  c             C   sj   t dd| dd}|  ||¡} |}| dkr2tjdfS x2t| |ƒD ]$\}}td|ƒ t||ƒ}|r>|S q>W dS )a€  
    Try to integrate f dx from zero to infinity.

    The body of this function computes various 'simplifications'
    f1, f2, ... of f (e.g. by calling expand_mul(), trigexpand()
    - see _guess_expansion) and calls _meijerint_definite_3 with each of
    these in succession.
    If _meijerint_definite_3 succeeds with any of the simplified functions,
    returns this result.
    rq   zmeijerint-definite2T)Zpositiver   ZTryingN)rä   rœ   r   r²   r—  r  Ú_meijerint_definite_3)rd   rq   ÚdummyrÉ   Zexplanationrl   re   re   rf   r“  Ÿ  s    


r“  c                sœ   t | ˆ ƒ}|r|d dkr|S | jr˜tdƒ ‡ fdd„| jD ƒ}tdd„ |D ƒƒr˜g }tj}x"|D ]\}}||7 }||g7 }qbW t|Ž }|dkr˜||fS dS )	z²
    Try to integrate f dx from zero to infinity.

    This function calls _meijerint_definite_4 to try to compute the
    integral. If this fails, it tries using linearity.
    rM   Fz#Expanding and evaluating all terms.c                s   g | ]}t |ˆ ƒ‘qS re   )rr  )rb   rÉ   )rq   re   rf   r©   É  s    z)_meijerint_definite_3.<locals>.<listcomp>c             s   s   | ]}|d k	V  qd S )Nre   )rb   r   re   re   rf   rg   Ê  s    z(_meijerint_definite_3.<locals>.<genexpr>N)rr  Zis_Addr  rj   ri   r   r²   rO   )rd   rq   rl   Úressr  r   r¦   re   )rq   rf   r˜  ½  s    
r˜  c             C   s   t t| ƒƒS )N)r  r!   )rd   re   re   rf   rs  Õ  s    rs  c          
   C   s.  t d| ƒ |sàt| |dd}|dk	rà|\}}}}t d|||ƒ tj}xf|D ]^\}	}
} |	dkr^qJt||	 |||
  | |ƒ\}	} ||	t| |ƒ 7 }t|t| |ƒƒ}|dkrJP qJW t|ƒ}|dkrÆt dƒ nt d|ƒ tt	|ƒƒ|fS t
| |ƒ}|dk	r*x2d	D ](}|\}}}}}t d
||||ƒ tj}x¶|D ]®\}}}xž|D ]’\}}}t|| | ||||   ||||ƒ}|dkr‚t dƒ dS |\}	}}t d|	||ƒ t|t|||ƒƒ}|dkr¸P ||	t|||ƒ 7 }q<W q,P q,W t|ƒ}|dkrþt d| ƒ qüt d|ƒ |r||fS tt	|ƒƒ|fS qüW dS )a  
    Try to integrate f dx from zero to infinity.

    Explanation
    ===========

    This function tries to apply the integration theorems found in literature,
    i.e. it tries to rewrite f as either one or a product of two G-functions.

    The parameter ``only_double`` is used internally in the recursive algorithm
    to disable trying to rewrite f as a single G-function.
    r  F)r}  Nz#Could rewrite as single G function:r   zBut cond is always False.z&Result before branch substitutions is:)FTz!Could rewrite as two G functions:zNon-rational exponents.zSaxena subst for yielded:z&But cond is always False (full_pb=%s).)r  r€  r   r²   r  r  rO   r  rs  rY   r‚  r(  rV  rX  )rd   rq   rq  rË   r}   rÈ   rÉ   r~   rl   r×   r  r	  r  r  r$  Ús1Úf1r%  Ús2Úf2r   Zf1_Zf2_re   re   rf   rr  Ù  s`    









rr  c             C   sf  | }|}t ddd}|  ||¡} td| ƒ t| |ƒs@tdƒ dS tj}| jrXt| jƒ}nt	| t
ƒrj| g}nd}|r°g }g }x |rž| ¡ }	t	|	t
ƒrt|	ƒ}
|
jr´||
j7 }q€yt|	jd |ƒ\}}W n tk
rä   d}Y nX |dkrú| |¡ n
| |	¡ q€|	jr’t|	ƒ}
|
jr*||
j7 }q€||	jjkr†yt|	j
|ƒ\}}W n tk
rf   d}Y nX |dkr†| |t|	jƒ ¡ | |	¡ q€| |	¡ q€W t|Ž }t|Ž } || jkrtd	| |ƒ tt|ƒdƒ}|d
krìtdƒ dS | t|| ƒ }td||ƒ t| ||¡|fƒS t| |ƒ}|dk	rb|\}}}}td|||ƒ tj}xb|D ]Z\}}} t|| |||  | |ƒ\}} ||t| ||ƒ 7 }t|t| |ƒƒ}|d
krVP qVW t|ƒ}|d
krÐtdƒ n’td|ƒ tt |ƒƒ}| !t"¡sþ|t"|ƒ9 }| ||| ¡}t	|t#ƒs*| ||| ¡}ddl$m%} t| ||¡|f|| ||¡||dƒdfƒS dS )aê  
    Compute the inverse laplace transform
    $\int_{c+i\infty}^{c-i\infty} f(x) e^{tx}\, dx$,
    for real c larger than the real part of all singularities of ``f``.

    Note that ``t`` is always assumed real and positive.

    Return None if the integral does not exist or could not be evaluated.

    Examples
    ========

    >>> from sympy.abc import x, t
    >>> from sympy.integrals.meijerint import meijerint_inversion
    >>> meijerint_inversion(1/x, x, t)
    Heaviside(t)
    r”   T)r  zLaplace-invertingzBut expression is not analytic.Nr   rM   z.Expression consists of constant and exp shift:Fz3but shift is nonreal, cannot be a Laplace transformz1Result is a delta function, possibly conditional:z#Could rewrite as single G function:zBut cond is always False.z"Result before branch substitution:)ÚInverseLaplaceTransform)&r   rœ   r  rç   r   r²   Zis_Mulr¢   rj   rÂ   r'   Úpopr
   r·   r¯   rw   r³   r´   rª   r)   r   r   r   r   r:   r0   r€  rY  rg  rO   rd  rs  rY   rk   r;   r  rv  rŸ  )rd   rq   r”   r~  Zt_Úshiftrj   r  Zexponentialsr   r  r„   r“   r~   rl   rË   r}   rÈ   rÉ   r×   r  rŸ  re   re   rf   Úmeijerint_inversion   s     















r¢  )T)F)F)F)T)T)F)³r°   Útypingr   ZtDictr   ZtTupleZsympyr   Z
sympy.corer   r   Zsympy.core.addr   Zsympy.core.cacher   Zsympy.core.containersZsympy.core.exprtoolsr	   Zsympy.core.functionr
   r   r   r   r   Zsympy.core.mulr   Zsympy.core.numbersr   r   r   Zsympy.core.relationalr   r   r   Zsympy.core.sortingr   r   Zsympy.core.symbolr   r   r   Z(sympy.functions.combinatorial.factorialsr   Z$sympy.functions.elementary.complexesr   r   r   r   r    r!   r"   r#   r$   r%   r&   Z&sympy.functions.elementary.exponentialr'   r(   r)   Z#sympy.functions.elementary.integersr*   Z%sympy.functions.elementary.hyperbolicr+   r,   r-   r.   Z(sympy.functions.elementary.miscellaneousr/   Z$sympy.functions.elementary.piecewiser0   r1   Z(sympy.functions.elementary.trigonometricr2   r3   r4   r5   Zsympy.functions.special.besselr6   r7   r8   r9   Z'sympy.functions.special.delta_functionsr:   r;   Z*sympy.functions.special.elliptic_integralsr<   r=   Z'sympy.functions.special.error_functionsr>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   Z'sympy.functions.special.gamma_functionsrI   Zsympy.functions.special.hyperrJ   rK   Z-sympy.functions.special.singularity_functionsrL   Z	integralsrN   Zsympy.logic.boolalgrO   rP   rQ   rR   rS   Zsympy.polysrT   rU   Zsympy.simplify.furV   Zsympy.simplifyrW   rX   rY   rZ   r[   r\   Zsympy.utilities.iterablesr]   Zsympy.utilities.miscr^   r  r_   ra   r§   Zsympy.utilities.timeutilsr¨   Ztimeitrv   ry  r¯   r·   r¼   rÁ   rÆ   rÊ   rÌ   rÏ   rØ   rÛ   rÜ   rå   rä   rß   rç   rë   r  r
  r  r  r  r(  rV  rX  rY  rd  rg  rw  r  r€  r‚  r†  r…  r’  r—  r“  r˜  rs  rr  r¢  re   re   re   rf   Ú<module>   s²   44 	 R!!$'	
{

s
H  3{ 
#Y F