U
     ‹Ñhš; ã                   @  sB  U d Z ddlmZ ddl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 ddlmZmZmZmZmZ ddlmZ ddlmZ ddl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*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z; ddl<m=Z=m>Z>m?Z? ddl@mAZA ddlBmCZCmDZDmEZEmFZF ddlGmHZH ddlImJZJmKZK ddlLmMZMmNZNmOZOmPZP ddlQmRZRmSZSmTZTmUZU ddlVmWZWmXZX ddlYmZZZm[Z[ ddl\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZg ddlhmiZi dd ljmkZkmlZl dd!lmmnZn d"d#lompZp dd$lqmrZrmsZsmtZtmuZumvZv dd%lwmxZxmyZy dd&lzm{Z{ dd'l|m}Z~ dd(l|mZ€ e(d)ƒZ�d*d+„ Z‚d,d-„ Zƒdd.l„m…Z… e…d/ƒZ†d0d1d2d3œd4d5„Z‡G d6d7„ d7eˆƒZ‰d8d9„ ZŠd:d;„ Z‹d<d=„ ZŒd>d?„ Z�d@dA„ ZŽdBdC„ Z�dDdE„ Z�dFdG„ Z‘dHdI„ Z’dJdK„ Z“i a”dLe•dM< dNdO„ Z–dPdQ„ Z—dRdS„ Z˜d†dUdV„Z™dWdX„ Zšd‡dZd[„Z›d\d]„ Zœdˆd^d_„Z�d`da„ Zžd‰dbdc„ZŸddde„ Z dfdg„ Z¡dhdi„ Z¢djdk„ Z£dldm„ Z¤da¥ee†dŠdndo„ƒƒZ¦d‹dpdq„Z§drds„ Z¨dtdu„ Z©dvdw„ Zªe†dxdy„ ƒZ«dzd{„ Z¬d|d}„ Z­d~d„ Z®d€d�„ Z¯e†dŒd‚dƒ„ƒZ°d„d…„ Z±dS )�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
é    )ÚannotationsN)ÚSYMPY_DEBUG)ÚSÚExpr)ÚAdd)ÚBasic)Úcacheit)ÚTuple)Ú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ÚSymbol)Úsympify)Ú	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)Úmultiset_partitions)Údebug)ÚdebugfÚ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© úG/tmp/user/2202/pip-unpacked-wheel-qe3242ng/sympy/integrals/meijerint.pyÚ	<genexpr>T   s     z_has.<locals>.<genexpr>)r6   ÚgetattrÚallÚargsÚhas)Úresrf   rg   re   rh   ra   O   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^   ©Únrg   rg   rh   ÚwildZ   s    z"_create_lookup_table.<locals>.wildZpqabcrr   c                 S  s   | j o| dkS ©Nr   )Ú
is_Integer©Úxrg   rg   rh   Ú<lambda>]   ó    z&_create_lookup_table.<locals>.<lambda>)Z
propertiesTc	           	   
     s6   ˆ   t| tƒg ¡ | |t|||||ƒfg||f¡ d S r`   )Ú
setdefaultÚ_mytyper^   ÚappendrP   )	ÚformulaÚanÚapÚbmÚbqr"   ÚfacÚcondÚhint©Útablerg   rh   Úadd`   s
      ÿz!_create_lookup_table.<locals>.addc                   s$   ˆ   t| tƒg ¡ | |||f¡ d S r`   )rz   r{   r^   r|   )r}   Úinstrƒ   r„   r…   rg   rh   Úaddid   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 ©NrR   r   )rP   r^   )Úarg   rg   rh   Úconstanth   s    ÿz&_create_lookup_table.<locals>.constantrg   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%   ru   )Úclsr"   rg   rg   rh   Úevalp   s    
z7_create_lookup_table.<locals>.IsNonPositiveInteger.evalN)Ú__name__Ú
__module__Ú__qualname__ÚclassmethodrŽ   rg   rg   rg   rh   ÚIsNonPositiveIntegern   s   r“   rR   r   )r„   é   c                 S  s(   t tddƒ | | d dd|     S )Néÿÿÿÿr”   rR   )r   r   )Úrr$   Únurg   rg   rh   Ú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”   rR   r3   ©r–   Zsgn)r˜   r‹   r‡   ÚbÚtrg   rh   Ú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”   rR   r   )r4   r^   r   ÚHalfr™   )r˜   r‹   r‡   rš   ÚpÚqrg   rh   rœ   —   s    D    þé   é   c                   s@   | ˆ  }t j| t|ƒ tg dg|d  dg|d  g ˆƒfgS rŠ   )r   ÚNegativeOner   rP   ©ÚsubsÚN©rr   r›   rg   rh   Ú	make_log1²   s    "ÿz'_create_lookup_table.<locals>.make_log1c                   s6   | ˆ  }t |ƒtdg|d  g g dg|d  ˆƒfgS rŠ   )r   rP   r£   r¦   rg   rh   Ú	make_log2·   s    "ÿz'_create_lookup_table.<locals>.make_log2c                   s   ˆ | ƒˆ| ƒ S r`   rg   ©r¤   )r§   r¨   rg   rh   Ú	make_log3Á   s    z'_create_lookup_table.<locals>.make_log3z3/2é   N)T)-ÚlistÚmapr   r^   r   ÚOner   r@   rN   rT   rW   r#   r8   r   r    r�   r+   r'   r0   r   r/   r4   r7   r9   r-   rP   rF   ÚImaginaryUnitr¢   rH   rI   rJ   rK   rG   rC   rD   rE   rL   rM   r;   r<   r=   r>   rA   rB   )r†   rs   Úcr‰   rŒ   r“   rœ   rª   rg   )r˜   r‹   r‡   rš   r§   r¨   rr   rž   rŸ   r›   r†   rh   Ú_create_lookup_tableX   s¾    
. 
ÿ. 
ÿ: 
ÿ: 
ÿ4
ÿ<, 
ÿ.ÿ



48**2  .þ(ÿþ"
ÿý248ÿ,
ÿÿ",,4>>.FD2(r±   )ÚtimethisrP   r   r   ztuple[type[Basic], ...])rf   rw   Úreturnc                   sN   dddœdd„}ˆ | j krdS | jr.t| ƒfS tt‡ fdd„| jD ƒ|d	�ƒS )
z4 Create a hashable entity describing the type of f. ztype[Basic]ztuple[int, int, str])rw   r³   c                 S  s   |   ¡ S r`   )Z	class_keyrv   rg   rg   rh   Úkey/  s    z_mytype.<locals>.keyrg   c                 3  s"   | ]}t |ˆ ƒD ]
}|V  qqd S r`   )r{   )rc   r‹   r›   rv   rg   rh   ri   6  s       z_mytype.<locals>.<genexpr>©r´   )Úfree_symbolsZis_FunctionÚtypeÚtupleÚsortedrl   )rf   rw   r´   rg   rv   rh   r{   -  s    

r{   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__rg   rg   rg   rh   rº   9  s   rº   c                 C  sz   ddl m} t|| ƒƒ |¡\}}|s0|tjfS |\}|jrX|j|krNtdƒ‚||j	fS ||krj|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)
    r   )Úpowsimpzexpr not of form a*x**bzexpr not of form a*x**b: %sN)Úsympy.simplifyr¼   r   Úas_coeff_mulr   ÚZeroÚis_PowÚbaserº   r+   r®   )Úexprrw   r¼   r°   Úmrg   rg   rh   Ú_get_coeff_exp@  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                   sV   | |kr|  dg¡ d S | jr:| j|kr:|  | jg¡ d S | jD ]}ˆ |||ƒ q@d S ©NrR   )ÚupdaterÀ   rÁ   r+   rl   )rÂ   rw   rn   Úargument©Ú_exponents_rg   rh   rÉ   u  s    
z_exponents.<locals>._exponents_©Úset)rÂ   rw   rn   rg   rÈ   rh   Ú
_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 rg   )r¶   Úfunc)rc   Úerv   rg   rh   Ú	<setcomp>…  s     
 z_functions.<locals>.<setcomp>)Úatomsr   )rÂ   rw   rg   rv   rh   Ú
_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 )ro   )r   ©rc   rr   rv   rg   rh   Ú
<listcomp>š  s     z*_find_splitting_points.<locals>.<listcomp>Zpqc                   sp   t | tƒsd S |  ˆˆ ˆ ¡}|rL|ˆ dkrL| |ˆ  |ˆ  ¡ d S | jrVd S | jD ]}ˆ ||ƒ q\d S rt   )Ú
isinstancer   Úmatchr‡   Zis_Atomrl   )rÂ   rn   rÃ   rÇ   ©Úcompute_innermostrž   rŸ   rw   rg   rh   r×   œ  s    

z1_find_splitting_points.<locals>.compute_innermostrÊ   )rÂ   rw   Ú	innermostrg   rÖ   rh   Ú_find_splitting_pointsˆ  s
    
rÙ   c           	      C  sÚ   t j}t j}t j}t| ƒ} t | ¡}|D ]¦}||kr>||9 }q(||jkrR||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(|||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))
    Fr©   )r   r®   r   r   Ú	make_argsr¶   rÀ   r+   rÁ   r¾   r   r%   r&   )	rf   rw   r‚   ÚpoÚgrl   r‹   r°   r›   rg   rg   rh   Ú
_split_mul¬  s(    






rÝ   c                 C  sf   t  | ¡}g }|D ]N}|jrV|jjrV|j}|j}|dk rF| }d| }||g| 7 }q| |¡ q|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   rR   )r   rÚ   rÀ   r+   ru   rÁ   r|   )rf   rl   ÚgsrÜ   rr   rÁ   rg   rg   rh   Ú	_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 rg   r   )rc   rw   Úyrg   rg   rh   rÓ     s     z%_mul_as_two_parts.<locals>.<listcomp>)rß   Úlenr¸   r[   )rf   rÞ   rg   rg   rh   Ú_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   ‡ fdd„t  | tˆ ƒ¡D ƒS )z5 (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) c                   s   g | ]\}}|| ˆ  ‘qS rg   rg   )rc   r‹   rd   rq   rg   rh   rÓ     s     z/_inflate_g.<locals>.inflate.<locals>.<listcomp>)Ú	itertoolsÚproductÚrange)Úparamsrr   rg   rq   rh   Úinflate  s    z_inflate_g.<locals>.inflaterR   r”   )r   rá   r   r�   r—   r   ÚdeltarP   r~   Úaotherr€   ÚbotherrÇ   )rÜ   rr   rç   ÚvÚCrg   rg   rh   Ú
_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 ©rR   rg   ©rc   r‹   rg   rg   rh   rÓ     s     z'_flip_g.<locals>.tr.<locals>.<listcomp>rg   ©Úlrg   rg   rh   Útr  s    z_flip_g.<locals>.trrR   )rP   r€   rê   r~   ré   rÇ   )rÜ   rò   rg   rg   rh   Ú_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”   rR   r•   c                   s   g | ]}|d  ˆ  ‘qS rî   rg   rÒ   ©rž   rg   rh   rÓ   8  s     z"_inflate_fox_h.<locals>.<listcomp>)Ú_inflate_fox_hró   r   rž   rŸ   rí   rÇ   r   r   rå   rP   r~   ré   r€   r¬   rê   )rÜ   r‹   rŸ   ÚDr^   Úbsrg   rô   rh   rõ   "  s    

&rõ   zdict[tuple[str, str], Dummy]Ú_dummiesc                 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Údrg   rg   rh   Ú_dummy>  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.
    )rø   r   )rú   rû   rü   rg   rg   rh   rù   J  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 r`   )r¶   ©rc   rÂ   rv   rg   rh   ri   X  s     z_is_analytic.<locals>.<genexpr>)ÚanyrÐ   r@   r#   )rf   rw   rg   rv   rh   Ú_is_analyticU  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‡ fd
d„| jD ƒŽ } d}|�rÊd}t|ƒD �]ü\}\}}|j| jk�ræ�qÆt| jƒD �]Î\}}	||jd jk�r"|	 |jd ¡‰d}
nd}
|	 |jd ¡‰ˆ�s@�qð‡fdd„|jd|
… |j|
d d…  D ƒ}|g‰|D ]Ø}t| jƒD ]Æ\}}|ˆk�rœ�q†||k�r¶ˆ|g7 ‰ �qxt|tƒ�r |jd |k�r t|tƒ�r |jd |jk�r ˆ|g7 ‰ �qxt|tƒ�r†|jd |k�r†t|tƒ�r†|jd |jk�r†ˆ|g7 ‰ �qx�q†�qxtˆƒt|ƒd k�rl�qð‡fdd„t| jƒD ƒ| ˆ¡g }t�rª|dk�rªtd|ƒ | j|Ž } d} �qÆ�qð�qÆ�q´‡‡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 r`   ©Zis_Relational©Ú_rg   rg   rh   rx   o  ry   z_condsimp.<locals>.<lambda>Fzp q r)r�   r”   r   rR   éþÿÿÿc                   s   g | ]}t |ˆ ƒ‘qS rg   )Ú	_condsimp)rc   r  )Úfirstrg   rh   rÓ   •  s     z_condsimp.<locals>.<listcomp>Tc                   s   g | ]}|  ˆ ¡‘qS rg   r©   ©rc   rw   )rÃ   rg   rh   rÓ   ¥  s     Nc                   s   g | ]\}}|ˆ kr|‘qS rg   rg   )rc   ÚkZarg_)Ú	otherlistrg   rh   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   rR   )Zrel_opÚrhsÚlhsrÕ   r"   r)   r'   rÔ   r*   rl   Zis_polarr   ÚInfinity)ÚrelZLHSrÃ   )rž   rŸ   rg   rh   Úrel_touchupÂ  s    ÿz_condsimp.<locals>.rel_touchupc                 S  s   | j S r`   r  r  rg   rg   rh   rx   Ñ  ry   z_condsimp: )Úreplacer   rÔ   rX   r   r   rU   r   rT   r#   r"   r   r   Úfalser   Útruer)   r,   r¯   r7   r4   rÍ   rl   Ú	enumerater¶   rÕ   rá   r¤   r   Úprint)rƒ   r  r–   ÚrulesZchangeZiruleÚfroÚtorr   Zarg1ÚnumZ	otherargsÚarg2r	  Zarg3Únewargsr  rg   )r  rÃ   r
  rž   rŸ   rh   r  [  sÄ    
(ÿ0ÿ0ÿ8ÿ8ÿ:ÿ6ÿ ÿþ"ÿ þ$40Bä.


ÿÿ
ÿÿ

ÿ



r  c                 C  s   t | tƒr| S t|  ¡ ƒS )z Re-evaluate the conditions. )rÔ   Úboolr  Zdoit)rƒ   rg   rg   rh   Ú
_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 r`   rg   )rw   rà   rg   rg   rh   rx   é  ry   z&_my_principal_branch.<locals>.<lambda>)r(   r  )rÂ   ÚperiodÚfull_pbrn   rg   rg   rh   Ú_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.
    rR   c                   s   ‡ ‡fdd„| D ƒS )Nc                   s    g | ]}|d ˆ ˆ   d  ‘qS rî   rg   rï   ©rš   Úsrg   rh   rÓ   ý  s     z1_rewrite_saxena_1.<locals>.tr.<locals>.<listcomp>rg   rð   r'  rg   rh   rò   ü  s    z_rewrite_saxena_1.<locals>.tr)
rÄ   rÇ   Ú
get_periodr&  r#   rP   r~   ré   r€   rê   )	r‚   rÛ   rÜ   rw   r  r‹   r$  rì   rò   rg   r'  rh   Ú_rewrite_saxena_1í  s    
 $ÿr*  c               
   C  sh  | j }t| j|ƒ\}}tt| jƒt| jƒt| jƒt| jƒgƒ\}}}}	||	krˆdd„ }
t	t
|
| jƒ|
| jƒ|
| jƒ|
| jƒ|| ƒ|ƒS dd„ | jD ƒdd„ | jD ƒ }t|Ž }|dd„ | jD ƒ7 }|dd„ | jD ƒ7 }t|Ž }t| jƒ |	d | d	  |	| k}d
d„ }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}tt|d	 ƒd ƒD ]*}|ttt|ƒƒ|d	|  t ƒg7 }�qò|dktt|ƒƒ|t k g}t|dƒ|g}|�rRg }|||fD ]}|t|| | Ž g7 }�q\||7 }|d|ƒ |g}|�rœg }tt|dƒ|d |k||	ktt|ƒƒ|t k f|žŽ g}||7 }|d|ƒ ||g}|�røg }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 }t| j| jƒD ]\}}||| g7 }�qÄ|tt|Ž ƒdk g7 }t|Ž }||g7 }|d|gƒ t|dktt|ƒƒ|t k ƒg}|�sB||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 rî   rg   r  rg   rg   rh   rÓ     s     z4_check_antecedents_1.<locals>.tr.<locals>.<listcomp>rg   rð   rg   rg   rh   rò     s    z _check_antecedents_1.<locals>.trc                 S  s   g | ]}t |ƒ d k ‘qS rî   ©r    ©rc   rš   rg   rg   rh   rÓ     s     z(_check_antecedents_1.<locals>.<listcomp>c                 S  s   g | ]}d d t |ƒ k ‘qS rî   r+  rï   rg   rg   rh   rÓ     s     c                 S  s   g | ]}t |ƒ d k ‘qS rî   r+  r,  rg   rg   rh   rÓ     s     c                 S  s   g | ]}d d t |ƒ k ‘qS rî   r+  rï   rg   rg   rh   rÓ     s     rR   r”   c                  W  s   t | Ž  d S r`   )Ú_debug)Úmsgrg   rg   rh   r\   "  s    z#_check_antecedents_1.<locals>.debugc                 S  s   t | |ƒ d S r`   ©Ú_debugf)Ústringr"   rg   rg   rh   r]   %  s    z$_check_antecedents_1.<locals>.debugfz$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€   r~   r   r�   Ú_check_antecedents_1rP   rê   ré   rT   r    r—   r¬   r   rW   rå   r.   r   r#   r)   r   Úzipr   rU   ) rÜ   rw   Úhelperrè   Úetar  rÃ   rr   rž   rŸ   rò   ÚtmpZcond_3Zcond_3_starZcond_4r\   r]   ÚcondsZcase1Ztmp1Ztmp2Ztmp3r	  Úextrar›   Zcase2Zcase3Z
case_extrar(  r‹   rš   Zcase_extra_2rg   rg   rh   r2    sž    0  ÿþ $ÿ8(
ÿÿ
*ÿ4
,

 

r2  c                 C  s¨   ddl m} t| j|ƒ\}}d| }| jD ]}|t|d ƒ9 }q*| jD ]}|td| d ƒ9 }qF| jD ]}|td| d ƒ }qf| jD ]}|t|d ƒ }q†|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))
    r   )Ú	gammasimprR   )
r½   r9  rÄ   rÇ   r€   rN   r~   rê   ré   r%   )rÜ   rw   r9  r5  r  rn   rš   r‹   rg   rg   rh   Ú	_int0oo_1r  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|ˆ ƒ}dd	lm} || 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 r`   )	rÄ   rÇ   r)  rP   r~   ré   r€   rê   r&  )rÜ   r‹   rš   Zper)r%  rw   rg   rh   Úpb«  s
    ÿz_rewrite_saxena.<locals>.pbr   TNrR   c                   s   ‡ fdd„| D ƒS )Nc                   s   g | ]}|ˆ  ‘qS rg   rg   rï   ©r+   rg   rh   rÓ   Ñ  s     z/_rewrite_saxena.<locals>.tr.<locals>.<listcomp>rg   rð   r<  rg   rh   rò   Ð  s    z_rewrite_saxena.<locals>.tr©Ú	powdenest©Zpolar)rÄ   rÇ   ró   Úis_Rationalrž   rŸ   r   rí   r#   rP   r~   ré   r€   rê   r½   r>  )r‚   rÛ   Úg1Úg2rw   r%  r;  r  r(  Úb1Úb2Úm1Zn1Úm2Zn2ÚtauÚr1Zr2ÚC1ÚC2Úa1rš   Úa2rò   r>  rg   )r+   r%  rw   rh   Ú_rewrite_saxena�  s>    ,rM  c           +        s&  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||ƒ}�z¤ˆˆ 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
�r,   d}!Y nX |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fD ]\}%}&td%|&|%fƒ �qŒ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”   rR   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                    sH   ˆ ˆfD ]:} t  | j| j¡D ]$\}}|| }|jr|jr  dS qqdS )NFT)rã   rä   r~   r€   Ú
is_integerÚis_positive)rÜ   rd   ÚjZdiff)rA  rB  rg   rh   Ú_c1ú  s    z_check_antecedents.<locals>._c1c                   s,   g | ]$}ˆ j D ]}td | | ƒdk‘qqS ©rR   r   )r€   r    ©rc   rd   rP  ©rB  rg   rh   rÓ     s       z&_check_antecedents.<locals>.<listcomp>c                   s,   g | ]$}ˆ j D ]}td | | ƒdk ‘qqS )rR   r”   )r~   r    rS  rT  rg   rh   rÓ     s       c                   s6   g | ].}ˆˆ t d | d  ƒ t ˆ ƒ tddƒk‘qS ©rR   éýÿÿÿr”   ©r    r   rb   ©Úmurž   rŸ   rg   rh   rÓ     s     c                   s2   g | ]*}ˆˆ t d | ƒ t ˆ ƒ tddƒk‘qS rU  rW  rb   rX  rg   rh   rÓ     s     c                   s6   g | ].}ˆˆ t d | d  ƒ t ˆ ƒ tddƒk‘qS rU  rW  rb   ©ÚrhoÚurë   rg   rh   rÓ     s     c                   s2   g | ]*}ˆˆ t d | ƒ t ˆ ƒ tddƒk‘qS rU  rW  rb   rZ  rg   rh   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)`
            rR   )r#   r"   r   ©r^   rg   rg   rh   Ú_cond$  s    z!_check_antecedents.<locals>._condFc                   sP   | ˆˆ  t ˆ ƒdˆˆ    tˆƒ |ˆˆ  t ˆƒdˆˆ    tˆƒ  S rÅ   )r#   r8   )Úc1Úc2)Úomegarž   ÚpsirŸ   ÚsigmaÚthetar\  rë   rg   rh   Ú	lambda_s0S  s    &&ÿz%_check_antecedents.<locals>.lambda_s0r•   Tr¡   r    r  r  r  é   é	   é
   r  r  r  r  é   z	  c%s: %sc                   s   t d| ˆ d fƒ d S )Nz  case %s: %sr•   r/  )Úcount)r7  rg   rh   Úprl  s    z_check_antecedents.<locals>.prr«   é   é   é   é   é   é   é   )r4  ZE1ZE2ZE3ZE4é   é   é   é   é   é   é   é   é    é!   é"   é#   )rÄ   rÇ   r   rá   r€   r~   r   r�   r—   r   r#   r)   r-  r0  rT   r    r   r+   r¯   r%   rU   r   r7   r#  r5   r$   Ú	TypeErrorrO  Zis_negativer2  )+rA  rB  rw   r  r(  r›   rÃ   rr   ZbstarZcstarÚphir5  rQ  r_  r`  Úc3Zc4Zc5Zc6Zc7Zc8Zc9Zc10Zc11Zc12Zc13Zz0ZzosZzsoZc14r^  Zc14_altZlambda_cZc15re  Zlambda_sr6  rƒ   rd   rk  Z
mt1_existsZ
mt2_existsr–   rg   )r7  rA  rB  rY  ra  rž   rb  rŸ   r[  rc  rd  r\  rë   rh   Ú_check_antecedentsÙ  sj   00$$ÿÿ*ÿÿ
ÿ*ÿÿ
ÿ ÿÿ"ÿÿ"ÿÿ

""ÿÿ"ÿ"ÿùþ
$       þ.ÿ.   ÿ.   ÿ$  
 
   þ$     þ      ÿ      ÿ      ÿ      ÿ(
     ÿ(
     ÿ(
     ÿ(
     ÿ      ÿ      ÿ        ÿ        ÿ2222     ÿ     ÿ,,,,6    þ6    þ0     þ0     þ.     ý
         ü6    þ6    þ0     ý0     ý  
       ü  
       ür‚  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(((0, 1/2), ()), ((m/2,), (-m/2,)), s**(-2))/s**2
    c                 S  s   dd„ | D ƒS )Nc                 S  s   g | ]
}| ‘qS rg   rg   r  rg   rg   rh   rÓ     s     z(_int0oo.<locals>.neg.<locals>.<listcomp>rg   rð   rg   rg   rh   Úneg  s    z_int0oo.<locals>.neg)rÄ   rÇ   r€   r¬   r~   ré   rê   rP   )rA  rB  rw   r5  r  ra  rƒ  rK  rL  rC  rD  rg   rg   rh   Ú_int0oo	  s    r„  c                   sz   t ||ƒ\}‰t |j|ƒ\}‰ ‡ ‡fdd„}ddlm} || |ˆˆ    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 rg   rg   )rc   r›   r'  rg   rh   rÓ   ,  s     z2_rewrite_inversion.<locals>.tr.<locals>.<listcomp>rg   rð   r'  rg   rh   rò   +  s    z_rewrite_inversion.<locals>.trr   r=  Tr?  )	rÄ   rÇ   r½   r>  rP   r~   ré   r€   rê   )r‚   rÛ   rÜ   rw   r  r‹   rò   r>  rg   r'  rh   Ú_rewrite_inversion&  s    (ÿr…  c                   sL  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�sV|d	k�rJ||k�sVt dƒ dS t ˆ jˆ j¡D ].\}}|| j�rf||k�rft dƒ  dS �qf||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   rT   rU   r   r   r!   )r‹   rš   r°   r^   ÚplusÚcoeffÚexponentr7  ZwpZwmÚwrv   rg   rh   Ústatement_half<  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)rT   )r‹   rš   r°   r^   )rŠ  rg   rh   Ú	statementN  s    ÿz/_check_antecedents_inversion.<locals>.statementr”   rR   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 rR  rg   rï   ©r‹  r^   rg   rh   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 rR  rg   rï   rŒ  rg   rh   rÓ     s     z;_check_antecedents_inversion.<locals>.E.<locals>.<listcomp>)rT   r~   r]  )rÜ   r‹  r]  rh   ÚE~  s    z'_check_antecedents_inversion.<locals>.Ec                   s   ˆˆˆ  dˆ  | ƒS rÅ   rg   r]  )rc  r‹  rd  rg   rh   ÚH�  s    z'_check_antecedents_inversion.<locals>.Hc                   s   ˆˆˆ  dˆ  | dƒS )NrR   Trg   r]  ©rc  rŠ  rd  rg   rh   ÚHp„  s    z(_check_antecedents_inversion.<locals>.Hpc                   s   ˆˆˆ  dˆ  | dƒS )NrR   Frg   r]  r�  rg   rh   ÚHm‡  s    z(_check_antecedents_inversion.<locals>.Hm)r-  rÇ   rÄ   Ú_check_antecedents_inversionró   r   rá   r€   r~   r   r�   r�   ÚNaNr   rè   r0  rã   rä   rN  rT   r   r+   r¯   rU   )rÜ   rw   r  rÎ   rÃ   rr   rž   rŸ   rG  r—   r[  Úepsilonrè   r‹   rš   r�  rŽ  r�  r‘  r7  rg   )rÜ   rc  r‹  rŠ  rd  rw   r^   rh   r’  2  s†    0$ÿ$
	
(ÿ.ý ÿ$$ÿ 
 ü(ýr’  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õ   rP   r~   ré   r€   rê   )rÜ   rw   r›   rš   r‹   rì   rg   rg   rh   Ú_int_inversion¬  s    ,r•  c                    sB  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�rjt| }	|	D �]„\}
}}}| j|
dd�}|râi }| ¡ D ]"\}}tt|dd�dd�||< �q|}t|tƒ�sL| |¡}|d	k�rXqât|ttfƒ�svt| |¡ƒ}t|ƒd	k�r†qât|tƒ�sš||ƒ}g }|D ]´\}}t t| |¡ t|¡dd�|ƒ}z| |¡ t|¡}W n t!k
�rü   Y �q¢Y nX t"||f Ž  #t$j%t$j&t$j'¡�r"�q¢t|j|j|j|jt|j
dd�ƒ}| (||f ¡ �q¢|râ||f  S qâ|�stdS t)d
ƒ ‡ ‡fdd„}|} t*dd| ƒ}dd„ }z,|| |||d	dd�\}}}|||||ƒ}W n |k
�rè   d}Y nX |dk�rrt+ddƒ}|| j,k�rrt-| |ƒ�rrz@||  ||| ¡|||dd	d�\}}}|||||ƒ |d¡}W n |k
�rp   d}Y nX |dk�s’| #t$j%t$j.t$j&¡�ržt)dƒ dS t/ 0|¡}g }|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°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.
    rR   )Úmellin_transformÚinverse_mellin_transformÚIntegralTransformErrorÚMellinTransformStripErrorNr   T)Úold)Zlift)Zexponents_onlyFz)Trying recursive Mellin transform method.c                   s\   zˆ| |||ddd�W S  ˆ k
rV   ddl m} ˆ|tt| ƒƒƒ|||ddd� Y 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Úneedevalr   )ÚsimplifyN)r½   rœ  rY   r   )ÚFr(  rw   Ústriprœ  ©r™  r—  rg   rh   Úmy_imt
  s    
 ÿ    þz_rewrite_single.<locals>.my_imtr(  zrewrite-singlec                 S  sp   t | |dd�}|d k	r\ddlm} |\}}t||dd�ƒ}t||ft| |tjtjfƒdfƒS t| |tjtjfƒS )NT)Úonly_doubler   ©ÚhyperexpandZnonrepsmall)Zrewrite)	Ú_meijerint_definite_4r½   r£  Ú_my_unpolarifyr5   rS   r   r¿   r  )rf   rw   r–   r£  rn   rƒ   rg   rg   rh   Úmy_integrator  s    ÿz&_rewrite_single.<locals>.my_integrator)Ú
integratorrœ  r›  r‹   )r§  r›  rœ  z"Recursive Mellin transform failed.zUnexpected form...z"Recursive Mellin transform worked:)2Ú
transformsr–  r—  r˜  r™  Ú_lookup_tabler±   rÔ   rP   rZ   rÇ   r¾   rá   rÀ   rÁ   r+   r@  r~   ré   r€   rê   r¤   r^   r{   rÕ   Úitemsr%   r&   r"  rV   r#  r¬   rÄ   Ú
ValueErrorr	   rm   r   r  ÚComplexInfinityÚNegativeInfinityr|   r-  rþ   rù   r¶   r  r“  r   rÚ   ÚNotImplementedError) rf   rw   Ú	recursiver–  r˜  r‡  rÃ   Úf_r›   rñ   r}   Ztermsrƒ   r„   r¤   Zsubs_r  r  rn   r‚   rÜ   rH  r   r(  r¦  r�  rž  r  r‹   rl   r°   rš   rg   rŸ  rh   Ú_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   rR   N)rÝ   r±  )rf   rw   r¯  r‚   rÛ   rÜ   rg   rg   rh   Ú	_rewrite1J  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ƒƒ}t d|¡D ]`\}\}}t|ˆ |ƒ}	t|ˆ |ƒ}
|	rv|
rvt	|	d	 |
d	 ƒ}|d
krv|||	d |
d |f  S qvd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±  rÿ   rv   rg   rh   ri   a  s     z_rewrite2.<locals>.<genexpr>Nc                   s&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS ©Nr   rR   )Úmaxrá   rÌ   rô   rv   rg   rh   rx   g  ry   z_rewrite2.<locals>.<lambda>c                   s&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS r³  )r´  rá   rÑ   rô   rv   rg   rh   rx   h  ry   c                   s&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS r³  )r´  rá   rÙ   rô   rv   rg   rh   rx   i  s   ÿ©FTrR   Fr   )
rÝ   r   rß   râ   r¬   r   rã   rä   r±  rT   )rf   rw   r‚   rÛ   rÜ   rñ   r¯  Zfac1Zfac2rA  rB  rƒ   rg   rv   rh   Ú	_rewrite2X  s$    


ýr¶  c                 C  sä   t | ƒ} g }tt| |ƒtjhB td�D ]P}t|  ||| ¡|ƒ}|sFq&| ||| ¡}t|t	t
ƒrn| |¡ q&|  S q&|  t¡rÐtdƒ tt| ƒ|ƒ}|rÐt|tƒsÆddlm} |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)
    rµ   ú*Try rewriting hyperbolics in terms of exp.r   ©ÚcollectN)r   r¹   rÙ   r   r¿   r   Ú_meijerint_indefinite_1r¤   ra   rO   rP   r|   rm   r2   r-  Úmeijerint_indefiniter1   rÔ   r¬   Úsympy.simplify.radsimpr¹  r
   rÐ   r+   ÚextendÚnextr   )rf   rw   Úresultsr‹   rn   Úrvr¹  rg   rg   rh   r»  u  s.    

 ÿ

r»  c                   s<  t d| dˆƒ ddlm}m} t| ˆƒ}|dkr4dS |\}}}}t d|ƒ tj}	|D �]\\}
}}t|jˆƒ\}}t|ˆƒ\}}||7 }||
 ˆd|   | }|d | ‰ t	dd	tj
ƒ}‡ fd
d„}tdd„ ||jƒD ƒƒ�rtt|jƒt|jƒdˆ  g t|jƒˆ  g t|jƒ|ƒ }n:tt|jƒdˆ  g t|jƒt|jƒt|jƒˆ  g |ƒ}|j�r~|  ˆd¡ tjtj¡�s~d}nd}|| ||ˆ|  ¡|d�}|	||| dd�7 }	qT‡fdd„}t|	dd�}	|	j�rg }|	jD ]$\}}t||ƒƒ}|||fg7 }�qÞ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wrtr   )r£  r>  Nz could rewrite:rR   r›   zmeijerint-indefinitec                   s   ‡ fdd„| D ƒS )Nc                   s   g | ]}|ˆ  ‘qS rg   rg   rï   ©r[  rg   rh   rÓ   »  s     z7_meijerint_indefinite_1.<locals>.tr.<locals>.<listcomp>rg   rô   rÁ  rg   rh   rò   º  s    z#_meijerint_indefinite_1.<locals>.trc                 s  s    | ]}|j o|d kdkV  qdS )r   TN)rN  r,  rg   rg   rh   ri   ¼  s     z*_meijerint_indefinite_1.<locals>.<genexpr>)ÚplaceTr?  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 does not 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)ÚdeeprR   )r   rY   r   Z
_from_argsZas_coeff_add)rn   rv   rg   rh   Ú_cleanÎ  s    z'_meijerint_indefinite_1.<locals>._clean)ÚevaluaterÅ  F)r-  r½   r£  r>  r²  r   r¿   rÄ   rÇ   rþ   r®   r   r€   rP   r¬   r~   ré   rê   Zis_extended_nonnegativer¤   rm   r“  r¬  r6   r_   rl   r¥  r5   rS   )rf   rw   r£  r>  rÞ   r‚   rÛ   Úglrƒ   rn   rì   r(  rÜ   r‹   rš   r  r°   Zfac_r›   rò   r–   rÂ  rÄ  r!  rÎ   rg   )r[  rw   rh   rº  š  s\    


    ÿ    ÿ"rº  c                 C  sú  t d| |||fƒ t| ƒ} |  t¡r0tdƒ dS |  t¡rFt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|
ƒ 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�rjtdƒ qö|\}}|\}}tt||ƒƒ}|dk�rœtdƒ qö|| }||f  S �n´|tjk�rât| ||tjƒ}|d  |d fS ||ftj	tjfk�r,t| |ƒ}|�rht|d tƒ�r$|	 |¡ n|S �n<|tjk�r¶t| |ƒD ]r}|| dkdk�rBt d|ƒ t|  ||| ¡t|| | ƒ |ƒ}|�rBt|d tƒ�rª|	 |¡ n|  S �qB|  ||| ¡} || }d}|tjk	�r"ttjt|ƒ ƒ}t|ƒ}|  ||| ¡} | t|| ƒ| 9 } tj}td||ƒ td| ƒ t| |ƒ}|�rht|d tƒ�rd|	 |¡ n|S | t¡�rätdƒ tt|ƒ|||ƒ}|�rät|tƒ�sÚddl m!} |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.
    z$Integrating %s wrt %s from %s to %s.z+Integrand has DiracDelta terms - giving up.Nz5Integrand has Singularity Function terms - giving up.rw   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   rR   zTrying x -> x + %szChanged limits tozChanged function tor·  r¸  )'r0  r   rm   r?   r-  rQ   r   r¤   r   r¿   r­  r  Úmeijerint_definiterÙ   r¹   r   Zis_extended_realÚ_meijerint_definite_2r  rT   ra   rP   r|   r@   r+   r¯   r"   r#   r2   r1   rÔ   r¬   r¼  r¹  r
   rÐ   r½  r¾  r   )rf   rw   r‹   rš   r°  Zx_Za_Zb_rý   r¿  rØ   r°   Zres1Zres2Zcond1Zcond2rƒ   rn   Úsplitr€  rÀ  r¹  rg   rg   rh   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äddl	m
} ||ƒ}||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_mul)Úsincos_to_sumztrig power reduction)r   r‡   r   rm   r:   r2   r   r7   r8   Zsympy.simplify.furË  )rf   rw   rn   ÚorigZsawÚexpandedrË  Zreducedrg   rg   rh   Ú_guess_expansion  s.    




rÎ  c                 C  sj   t dd| dd�}|  ||¡} |}| dkr2tjdfS t| |ƒD ](\}}td|ƒ t||ƒ}|r<|  S q<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.
    rw   zmeijerint-definite2T)Zpositiver   ZTryingN)rþ   r¤   r   r¿   rÎ  r-  Ú_meijerint_definite_3)rf   rw   ÚdummyrÜ   Zexplanationrn   rg   rg   rh   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}|D ]\}}||7 }||g7 }q`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.
    rR   Fz#Expanding and evaluating all terms.c                   s   g | ]}t |ˆ ƒ‘qS rg   )r¤  )rc   rÜ   rv   rg   rh   rÓ   É  s     z)_meijerint_definite_3.<locals>.<listcomp>c                 s  s   | ]}|d k	V  qd S r`   rg   )rc   r–   rg   rg   rh   ri   Ê  s     z(_meijerint_definite_3.<locals>.<genexpr>N)r¤  Zis_Addr-  rl   rk   r   r¿   rT   )rf   rw   rn   Úressr7  r–   r°   rg   rv   rh   rÏ  ½  s    
rÏ  c                 C  s   t t| ƒƒS r`   )r#  r%   re   rg   rg   rh   r¥  Õ  s    r¥  c              
   C  sB  ddl m} td| ƒ |sêt| |dd�}|dk	rê|\}}}}td|||ƒ tj}	|D ]`\}
}} |
dkrhqTt||
 |||  | |ƒ\}
} |	|
t| |ƒ 7 }	t|t	| |ƒƒ}|dkrT q¶qTt
|ƒ}|dkrÐtdƒ ntd	|	ƒ t
||	ƒƒ|fS t| |ƒ}|dk	�r>d
D �]8}|\}}}}}td||||ƒ tj}	|D ]¸\}}}|D ]œ\}}}t|| | ||||   ||||ƒ}|dk�rŠtdƒ    dS |\}
}}td|
||ƒ t|t|||ƒƒ}|dk�rÄ �qà|	|
t|||ƒ 7 }	�q>�q0 �qê�q0t
|ƒ}|dk�rtd|ƒ n2td|	fƒ |�r&|	|f  S t
||	ƒƒ|f  S �q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   r¢  ZIntegratingF)r¯  Nú#Could rewrite as single G function:úBut cond is always False.z&Result before branch substitutions is:rµ  z!Could rewrite as two G functions:zNon-rational exponents.zSaxena subst for yielded:z&But cond is always False (full_pb=%s).z)Result before branch substitutions is: %s)r½   r£  r-  r²  r   r¿   r*  r:  rT   r2  r¥  r¶  rM  r‚  r„  r0  )rf   rw   r¡  r£  rÞ   r‚   rÛ   rÜ   rƒ   rn   rì   r(  r%  rA  rB  rI  Ús1Úf1rJ  Ús2Úf2r–   Zf1_Zf2_rg   rg   rh   r¤  Ù  sj    





   ÿ





r¤  c                 C  sl  | }|}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 }|�rš| ¡ }	t	|	t
ƒ�rt|	ƒ}
|
jr°||
j7 }q|z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‚zt|	j
|ƒ\}}W n tk
�rb   d}Y nX |dk�r‚| |t|	jƒ ¡ | |	¡ q|| |	¡ q|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	�rh|\}}}}td|||ƒ tj}|D ]^\}}} t|| |||  | |ƒ\}} ||t| ||ƒ 7 }t|t| |ƒƒ}|d
k�rN �q®�qNt|ƒ}|d
k�rÊtdƒ nžtd|ƒ ddl m!} t||ƒƒ}| "t#¡�s|t#|ƒ9 }| ||| ¡}t	|t$ƒ�s0| ||| ¡}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›   Tr?  zLaplace-invertingzBut expression is not analytic.Nr   rR   z.Expression consists of constant and exp shift:Fz3but shift is nonreal, cannot be a Laplace transformz1Result is a delta function, possibly conditional:rÒ  rÓ  z"Result before branch substitution:r¢  )ÚInverseLaplaceTransform)'r   r¤   r-  r  r   r¿   Zis_Mulr¬   rl   rÔ   r+   Úpopr   rÄ   rº   r|   rÀ   rÁ   r¶   r-   r   r   r   r!   r?   r5   r²  r…  r•  rT   r’  r¥  r½   r£  rm   r@   r"  r¨  rØ  )rf   rw   r›   r°  Zt_Úshiftrl   r!  Zexponentialsr"   r   r‹   rš   rƒ   rn   rÞ   r‚   rÛ   rÜ   rì   r(  r£  rØ  rg   rg   rh   Úmeijerint_inversion!  s¤    















ÿrÛ  )T)F)F)F)T)T)F)²r»   Ú
__future__r   rã   Zsympyr   Z
sympy.corer   r   Zsympy.core.addr   Zsympy.core.basicr   Zsympy.core.cacher   Zsympy.core.containersr	   Zsympy.core.exprtoolsr
   Zsympy.core.functionr   r   r   r   r   Zsympy.core.mulr   Zsympy.core.intfuncr   Zsympy.core.numbersr   r   Zsympy.core.relationalr   r   r   Zsympy.core.sortingr   r   Zsympy.core.symbolr   r   r   r   Zsympy.core.sympifyr   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/   r0   r1   r2   Z(sympy.functions.elementary.miscellaneousr4   Z$sympy.functions.elementary.piecewiser5   r6   Z(sympy.functions.elementary.trigonometricr7   r8   r9   r:   Zsympy.functions.special.besselr;   r<   r=   r>   Z'sympy.functions.special.delta_functionsr?   r@   Z*sympy.functions.special.elliptic_integralsrA   rB   Z'sympy.functions.special.error_functionsrC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   Z'sympy.functions.special.gamma_functionsrN   Zsympy.functions.special.hyperrO   rP   Z-sympy.functions.special.singularity_functionsrQ   Z	integralsrS   Zsympy.logic.boolalgrT   rU   rV   rW   rX   Zsympy.polysrY   rZ   Zsympy.utilities.iterablesr[   Zsympy.utilities.miscr\   r-  r]   r0  r^   ra   r±   Zsympy.utilities.timeutilsr²   Ztimeitr{   r«  rº   rÄ   rÌ   rÑ   rÙ   rÝ   rß   râ   rí   ró   rõ   rø   Ú__annotations__rþ   rù   r  r  r#  r&  r*  r2  r:  rM  r‚  r„  r…  r’  r•  r©  r±  r²  r¶  r»  rº  rÈ  rÎ  rÉ  rÏ  r¥  r¤  rÛ  rg   rg   rg   rh   Ú<module>   sº   44	 R"!$'	
{

p
I  2z 
%Z
  G