U
    ZÊ¹jš; ã                   @  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© úX/var/www/html/bwave/python/venv/lib/python3.8/site-packages/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>)Ú
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`   )r{   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   r3    sž    0  ÿþ $ÿ8(
ÿÿ
*ÿ4
,

 

r3  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¾   r:  rÅ   rÈ   r�   rN   r   rë   rê   r%   )rÝ   rw   r:  r6  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Úr1Úr2ÚC1ÚC2Úa1r›   Úa2ró   r?  rg   )r+   r&  rw   rh   Ú_rewrite_saxena�  s>    ,rO  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   ÚjÚdiff)rB  rC  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   rR  ©rC  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    rV  rW  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 rX  rZ  rb   r[  rg   rh   rÔ     s     c                   s6   g | ].}ˆˆ t d | d  ƒ t ˆ ƒ tddƒk‘qS rX  rZ  rb   ©ÚrhoÚurì   rg   rh   rÔ     s     c                   s2   g | ]*}ˆˆ t d | ƒ t ˆ ƒ tddƒk‘qS rX  rZ  rb   r]  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–   r0  )Úcount)r8  rg   rh   Úprl  s    z_check_antecedents.<locals>.prr¬   é   é   é   é   é   é   é   )r5  ZE1ZE2ZE3ZE4é   é   é   é   é   é   é   é   é    é!   é"   é#   )rÅ   rÈ   r   râ   r�   r   r€   r‚   r˜   r   r#   r)   r.  r1  rT   r    r   r+   r°   r%   rU   r   r7   r$  r5   r$   Ú	TypeErrorrQ  Zis_negativer3  )+rB  rC  rw   r  r)  rœ   rÄ   rr   ZbstarZcstarÚphir6  rT  rb  rc  Úc3Zc4Zc5Zc6Zc7Zc8Zc9Zc10Zc11Zc12Zc13Zz0ZzosZzsoZc14ra  Zc14_altZlambda_cZc15rh  Zlambda_sr7  r„   rd   rn  Z
mt1_existsZ
mt2_existsr—   rg   )r8  rB  rC  r\  rd  rŸ   re  r    r^  rf  rg  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   )rB  rC  rw   r6  r  rd  r†  rM  rN  rD  rE  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Úexponentr8  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 rU  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 rU  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`  )rf  rŽ  rg  rg   rh   ÚH�  s    z'_check_antecedents_inversion.<locals>.Hc                   s   ˆˆˆ  dˆ  | dƒS )NrR   Trg   r`  ©rf  r�  rg  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é   r1  rä   rå   rP  rT   r   r+   r°   rU   )rÝ   rw   r  rÏ   rÄ   rr   rŸ   r    rH  r˜   r^  Úepsilonré   rŒ   r›   r�  r‘  r“  r”  r8  rg   )rÝ   rf  rŽ  r�  rg  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+   rA  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Ý   rI  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fac2rB  rC  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)rP  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»  )'r1  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   Úressr8  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   r3  r¨  r¹  rO  r…  r‡  r1  )rf   rw   r¤  r¦  rß   rƒ   rÜ   rÝ   r„   rn   rí   r)  r&  rB  rC  rK  Ús1Úf1rL  Ú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]   r1  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+  r3  r;  rO  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