o
    §ƒðj‡; ã                   @  s:  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†dˆd6d7„Z‡G d8d9„ d9eˆƒZ‰d:d;„ ZŠd<d=„ Z‹d>d?„ ZŒd@dA„ Z�dBdC„ ZŽdDdE„ Z�dFdG„ Z�dHdI„ Z‘dJdK„ Z’dLdM„ Z“i Z”dNe•dO< dPdQ„ Z–dRdS„ Z—dTdU„ Z˜d‰dWdX„Z™dYdZ„ ZšdŠd\d]„Z›d^d_„ ZœdŠd`da„Z�dbdc„ ZždŠddde„ZŸdfdg„ Z dhdi„ Z¡djdk„ Z¢dldm„ Z£dndo„ Z¤da¥ee†d‰dpdq„ƒƒZ¦d‰drds„Z§dtdu„ Z¨dvdw„ Z©dxdy„ Zªe†dzd{„ ƒZ«d|d}„ 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 |gˆ ¢R Ž V  qd S ©N)Ú_has©Ú.0Úi©Úf© ú›/tmp/claude-1000/-var-www-html-academy/3f42efd1-c2b7-4d08-9b05-30d86bb35479/scratchpad/piper/venv/lib/python3.10/site-packages/sympy/integrals/meijerint.pyÚ	<genexpr>T   ó   € 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   ó   z"_create_lookup_table.<locals>.wildÚpqabcrs   c                 S  s   | j o| dkS ©Nr   )Ú
is_Integer©Úxrg   rg   rh   Ú<lambda>]   s    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u r|dkS d S )NTr   )r%   rx   )Ú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™   Ú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2(þé   é   c                   s@   | ˆ  }t j| t|ƒ tg dg|d  dg|d  g ˆƒfgS r�   )r   ÚNegativeOner   rP   ©ÚsubsÚN©rs   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‰   rt   ÚcrŒ   r�   r–   r    r®   rg   )r›   rŽ   rŠ   rž   r«   r¬   rs   r¢   r£   rŸ   r‰   rh   Ú_create_lookup_tableX   s´   .
ÿ.ÿ:ÿ:ÿ4
ÿ<6ÿ.ÿ



48**2  .þ(ÿþ"
ÿý248ÿ,
ÿÿ",,4>>.FD2(8r¶   )ÚtimethisrP   rf   r   rz   r   Úreturnútuple[type[Basic], ...]c                   sH   ddd„}ˆ | j v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. rz   útype[Basic]r¸   útuple[int, int, str]c                 S  s   |   ¡ S r`   )Ú	class_keyry   rg   rg   rh   Úkey/  s   z_mytype.<locals>.keyrg   c                 3  s$   � | ]}t |ˆ ƒD ]}|V  q	qd S r`   )r~   )rc   rŽ   rŸ   ry   rg   rh   ri   6  s   €" z_mytype.<locals>.<genexpr>©r½   N)rz   rº   r¸   r»   )Úfree_symbolsÚis_FunctionÚtypeÚtupleÚsortedrm   )rf   rz   r½   rg   ry   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  sv   ddl m} t|| ƒƒ |¡\}}|s|tjfS |\}|jr,|j|kr'tdƒ‚||j	fS ||kr5|tj
fS td|  ƒ‚)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: %s)Úsympy.simplifyrÆ   r   Úas_coeff_mulr   ÚZeroÚis_PowÚbaserÄ   r+   r³   )Úexprrz   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+   rm   )rÌ   rz   ro   Úargument©Ú_exponents_rg   rh   rÓ   u  s   
ÿz_exponents.<locals>._exponents_©Úset)rÌ   rz   ro   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 v r|j’qS rg   )r¿   Úfunc)rc   Úery   rg   rh   Ú	<setcomp>…  ó    z_functions.<locals>.<setcomp>)Úatomsr   )rÌ   rz   rg   ry   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 )rp   )r   ©rc   rs   ry   rg   rh   Ú
<listcomp>š  ó    z*_find_splitting_points.<locals>.<listcomp>Úpqc                   sp   t | tƒsd S |  ˆˆ ˆ ¡}|r&|ˆ dkr&| |ˆ  |ˆ  ¡ d S | jr+d S | jD ]}ˆ ||ƒ q.d S rw   )Ú
isinstancer   ÚmatchrŠ   Úis_Atomrm   )rÌ   ro   rÍ   rÑ   ©Úcompute_innermostr¢   r£   rz   rg   rh   rå   œ  s   

ÿz1_find_splitting_points.<locals>.compute_innermostrÔ   )rÌ   rz   Ú	innermostrg   rä   rh   Ú_find_splitting_pointsˆ  s
   
rç   c           	      C  sÚ   t j}t j}t j}t| ƒ} t | ¡}|D ]S}||kr||9 }q||jvr)||9 }q|jrc||jjvrc|j 	|¡\}}||fkrIt
|jƒ 	|¡\}}||fkrc|||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   rz   r…   ÚpoÚgrm   rŽ   rµ   rŸ   rg   rg   rh   Ú
_split_mul¬  s(   







rë   c                 C  sf   t  | ¡}g }|D ]'}|jr+|jjr+|j}|j}|dk r#| }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+   rx   rË   r   )rf   rm   Úgsrê   rs   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   rz   Úyrg   rg   rh   rÞ     ó     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   rr   rg   rh   rÞ     rÚ   z/_inflate_g.<locals>.inflate.<locals>.<listcomp>)Ú	itertoolsÚproductÚrange)Úparamsrs   rg   rr   rh   Úinflate  s   z_inflate_g.<locals>.inflaterR   r—   )r   rð   r‚   r„   rš   r   ÚdeltarP   r�   Úaotherrƒ   ÚbotherrÑ   )rê   rs   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  ó   dd„ | D ƒS )Nc                 S  ó   g | ]}d | ‘qS ©rR   rg   ©rc   rŽ   rg   rg   rh   rÞ     ó    z'_flip_g.<locals>.tr.<locals>.<listcomp>rg   ©Úlrg   rg   rh   Útr  ru   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  ó    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  s0   t | |fi |¤Ž}||jv rt| fi |¤Ž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  s0   | |ft vrt| fi |¤Ž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  K  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 v V  qd S r`   )r¿   ©rc   rÌ   ry   rg   rh   ri   X  s   € z_is_analytic.<locals>.<genexpr>)ÚanyrÛ   r@   r#   )rf   rz   rg   ry   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v �r|	 |jd ¡‰d}
n
d}
|	 |jd ¡‰ˆ�s�q÷‡fdd„|jd|
… |j|
d d…  D ƒ}|g‰|D ]i}t| jƒD ]`\}}|ˆv �rL�qA||k�rXˆ|g7 ‰ nJt|tƒ�r||jd |k�r|t|tƒ�r||jd |jv �r|ˆ|g7 ‰ n&t|tƒ�r |jd |k�r t|tƒ�r |jd |jv �r ˆ|g7 ‰ n�qA�q:tˆƒt|ƒd k�r±�q÷‡fdd„t| jƒD ƒ| ˆ¡g }t�rÐ|dv�rÐtd|ƒ | j|Ž } d} �qã|�sÝ‡‡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  ó   | j S r`   ©Úis_Relational©Ú_rg   rg   rh   r{   o  ó    z_condsimp.<locals>.<lambda>Fzp q r)r�   r—   r   rR   éþÿÿÿc                   ó   g | ]}t |ˆ ƒ‘qS rg   )Ú	_condsimp)rc   r  )Úfirstrg   rh   rÞ   •  ó    z_condsimp.<locals>.<listcomp>Tc                   s   g | ]}|  ˆ ¡‘qS rg   r­   ©rc   rz   )rÍ   rg   rh   rÞ   ¥  r  Nc                   s   g | ]
\}}|ˆ vr|‘qS rg   rg   )rc   ÚkÚ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ˆ ƒˆ ¡}|s%| ttˆ ƒˆ ƒ¡}|sCt|tƒrA|j	d j
sA|j	d tju rA|j	d dkS | S |ˆ  dkS )Nz==r   rR   )Úrel_opÚrhsÚlhsrâ   r"   r)   r'   rá   r*   rm   Úis_polarr   ÚInfinity)ÚrelÚLHSrÍ   )r¢   r£   rg   rh   Úrel_touchupÂ  s   z_condsimp.<locals>.rel_touchupc                 S  r  r`   r  r  rg   rg   rh   r{   Ñ  r  z_condsimp: )Úreplacer   rá   rX   r   r   rU   r   rT   r#   r"   r   r   Úfalser   Útruer)   r,   r´   r7   r4   r×   rm   Ú	enumerater¿   râ   rð   r¨   r   Úprint)r†   r  r™   ÚrulesÚchangeÚiruleÚfroÚtors   Úarg1ÚnumÚ	otherargsÚarg2r!  Úarg3Únewargsr2  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  Údoit)r†   rg   rg   rh   Ú
_eval_condÖ  s   
rE  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   )rz   rî   rg   rg   rh   r{   é  s    z&_my_principal_branch.<locals>.<lambda>)r(   r3  )rÌ   ÚperiodÚfull_pbro   rg   rg   rh   Ú_my_principal_branchá  s   
rH  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                   ó   ‡ ‡fdd„| D ƒS )Nc                   s    g | ]}|d ˆ ˆ   d  ‘qS rÿ   rg   r   ©rž   Úsrg   rh   rÞ   ý  rï   z1_rewrite_saxena_1.<locals>.tr.<locals>.<listcomp>rg   r  rJ  rg   rh   r  ü  ó   z_rewrite_saxena_1.<locals>.tr)
rÎ   rÑ   Ú
get_periodrH  r#   rP   r�   rø   rƒ   rù   )	r…   ré   rê   rz   r  rŽ   rF  rû   r  rg   rJ  rh   Ú_rewrite_saxena_1í  s   
 $ÿrN  c               
   C  sl  | j }t| j|ƒ\}}tt| jƒt| jƒt| jƒt| jƒgƒ\}}}}	||	krDd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}|�r(g }|||fD ]}|t|| | Ž g7 }�q-||7 }|d|ƒ |g}|�rMg }tt|dƒ|d |k||	ktt|ƒƒ|t k g|¢R Ž g}||7 }|d|ƒ ||g}|�r|g }t||	k d|k|dkttt|ƒƒ|t ƒg|¢R Ž g}|t||	d	 kt|dƒttt|ƒƒdƒg|¢R Ž 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}|�s#||g7 }t|Ž }||g7 }|d|gƒ t|Ž S )aV  
    Return a condition under which the mellin transform of g exists.
    Any power of x has already been absorbed into the G function,
    so this is just $\int_0^\infty g\, dx$.

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

    If ``helper`` is True, only check if the MT exists at infinity, i.e. if
    $\int_1^\infty g\, dx$ exists.
    c                 S  rý   )Nc                 S  rþ   rÿ   rg   r   rg   rg   rh   rÞ     r  z4_check_antecedents_1.<locals>.tr.<locals>.<listcomp>rg   r  rg   rg   rh   r    ru   z _check_antecedents_1.<locals>.trc                 S  ó   g | ]	}t |ƒ d k ‘qS rÿ   ©r    ©rc   rž   rg   rg   rh   rÞ     rß   z(_check_antecedents_1.<locals>.<listcomp>c                 S  ó   g | ]
}d d t |ƒ k ‘qS rÿ   rP  r   rg   rg   rh   rÞ     rÚ   c                 S  rO  rÿ   rP  rQ  rg   rg   rh   rÞ     rß   c                 S  rR  rÿ   rP  r   rg   rg   rh   rÞ     rÚ   rR   r—   c                  W  s   t | Ž  d S r`   )Ú_debug)Úmsgrg   rg   rh   r\   "  ó   z#_check_antecedents_1.<locals>.debugc                 S  s   t | |ƒ d S r`   ©Ú_debugf)Ústringr"   rg   rg   rh   r]   %  ru   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ê   rz   Úhelperr÷   Úetar  rÍ   rs   r¢   r£   r  ÚtmpÚcond_3Úcond_3_starÚcond_4r\   r]   ÚcondsÚcase1Útmp1Útmp2Útmp3r!  ÚextrarŸ   Úcase2Úcase3Ú
case_extrarK  rŽ   rž   Úcase_extra_2rg   rg   rh   rY    sš   0ÿþ $ÿ8&
ÿ
ÿ
*
ÿ6
,

 

rY  c                 C  s¨   ddl m} t| j|ƒ\}}d| }| jD ]
}|t|d ƒ9 }q| jD ]}|td| d ƒ9 }q#| jD ]}|td| d ƒ }q3| jD ]
}|t|d ƒ }qC|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Ç   rk  rÎ   rÑ   rƒ   rN   r�   rù   rø   r%   )rê   rz   rk  r\  r  ro   rž   rŽ   rg   rg   rh   Ú	_int0oo_1r  s   



rl  c                   s´  ‡‡fdd„}t |ˆƒ\}}t |jˆƒ\}}	t |jˆƒ\}}
|	dk dkr+|	 }	t|ƒ}|
dk dkr8|
 }
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Ñ   rM  rP   r�   rø   rƒ   rù   rH  )rê   rŽ   rž   Úper)rG  rz   rg   rh   Úpb«  s
   ÿz_rewrite_saxena.<locals>.pbr   TNrR   c                   ó   ‡ fdd„| D ƒS )Nc                   ó   g | ]}|ˆ  ‘qS rg   rg   r   ©r+   rg   rh   rÞ   Ñ  r  z/_rewrite_saxena.<locals>.tr.<locals>.<listcomp>rg   r  rq  rg   rh   r  Ð  ó   z_rewrite_saxena.<locals>.tr©Ú	powdenest©Úpolar)rÎ   rÑ   r  Úis_Rationalr¢   r£   r   rü   r#   rP   r�   rø   rƒ   rù   rÇ   rt  )r…   ré   Úg1Úg2rz   rG  rn  r  rK  Úb1Úb2Úm1Ún1Úm2Ún2ÚtauÚr1Úr2ÚC1ÚC2Úa1rž   Úa2r  rt  rg   )r+   rG  rz   rh   Ú_rewrite_saxena�  s>   ,r‡  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�rj| 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�y   d}!Y nw |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ƒ �qDg ‰ ‡ fd&d'„}'ˆ t|| | | dk|jdu |	jdu |||||ƒg7 ‰ |'dƒ ˆ ttˆˆƒt|dƒ|	jdu ˆ	jdu tˆƒdk ||||ƒ	g7 ‰ |'dƒ ˆ ttˆˆƒt|	dƒ|jdu ˆjdu tˆƒdk ||||ƒ	g7 ‰ |'dƒ ˆ ttˆˆƒtˆˆƒt|dƒt|	dƒˆ	jdu ˆjdu tˆƒdk tˆƒdk tˆ	ˆƒ|||ƒg7 ‰ |'dƒ ˆ ttˆˆƒtˆˆƒt|dƒt|	dƒˆ	jdu ˆjdu tˆˆ ƒdk tˆˆ	ƒ|||ƒg7 ‰ |'dƒ ˆ tˆˆk|jdu |jdu |	dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆk |jdu |jdu |	dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆk|jdu |	jdu |dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆk |jdu |	jdu |dk||||||ƒ
g7 ‰ |'dƒ ˆ tˆˆktˆˆƒt|dƒ|	dkˆ	jdu tˆƒdk |||||ƒg7 ‰ |'dƒ ˆ tˆˆk tˆˆƒt|dƒ|	dkˆ	jdu tˆƒdk |||||ƒg7 ‰ |'d ƒ ˆ ttˆˆƒˆˆk|dkt|	dƒˆjdu tˆƒdk |||||ƒg7 ‰ |'d!ƒ ˆ ttˆˆƒˆˆk |dkt|	dƒˆjdu 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u |jdu |
jdu |||ƒg7 ‰ |'d*ƒ ˆ tt|dƒ|jdu |jdu |
jdu |||ƒg7 ‰ |'d+ƒ ˆ tt|dƒ|jdu |	jdu |
jdu |||ƒg7 ‰ |'d,ƒ ˆ tt|dƒ|jdu |	jdu |
jdu |||ƒg7 ‰ |'d-ƒ ˆ tt|| dƒ|jdu |	jdu |||||ƒg7 ‰ |'d.ƒ ˆ tt|| dƒ|jdu |	jdu |||||ƒg7 ‰ |'d/ƒ tˆ|dd0�}(tˆ|dd0�})ˆ t|)t|dƒˆ|k |jdu ||||ƒg7 ‰ |'d1ƒ ˆ t|)t|dƒˆ|k |jdu ||||ƒg7 ‰ |'d2ƒ ˆ t|(t|dƒˆ|k |	jdu ||||ƒg7 ‰ |'d3ƒ ˆ t|(t|dƒˆ|k |	jdu ||||ƒg7 ‰ |'d4ƒ tˆ Ž }*t|*ƒdk�rÛ|*S ˆ t|| ˆkt|dƒt|
dƒ|jdu |jdu |	jdu t
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d5ƒ ˆ t|| ˆkt|dƒt|
dƒ|jdu |jdu |	jdu t
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d6ƒ ˆ ttˆˆd ƒt|dƒt|
dƒ|jdu |jdu |	dk|	t	 t
tˆƒƒk |||||!ƒg7 ‰ |'d7ƒ ˆ ttˆˆd ƒt|dƒt|
dƒ|jdu |jdu |	dk|	t	 t
tˆƒƒk |||||!ƒg7 ‰ |'d8ƒ ˆ tˆˆd k t|dƒt|
dƒ|jdu |jdu |	dk|	t	 t
tˆƒƒk t
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d9ƒ ˆ tˆˆd kt|dƒt|
dƒ|jdu |jdu |	dk|	t	 t
tˆƒƒk t
tˆƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d:ƒ ˆ tt|dƒt|
dƒ|| dk|jdu |	jdu |jdu t
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d;ƒ ˆ tt|dƒt|
dƒ|| ˆk|jdu |	jdu |jdu t
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d<ƒ ˆ tt|dƒt|
dƒtˆˆd ƒ|jdu |	jdu |dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|d t	 k |||||!ƒg7 ‰ |'d=ƒ ˆ tt|dƒt|
dƒtˆˆd ƒ|jdu |	jdu |dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|d t	 k |||||!ƒg7 ‰ |'d>ƒ ˆ tt|dƒt|
dƒˆˆd k |jdu |	jdu |dk|t	 t
tˆ	ƒƒk t
tˆ	ƒƒ|| ˆ d t	 k |||||!ƒg7 ‰ |'d?ƒ ˆ tt|dƒt|
dƒˆˆd k|jdu |	jdu |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)rx  ry  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   rŠ  ©ry  rg   rh   rÞ     ó   , z&_check_antecedents.<locals>.<listcomp>c                   s,   g | ]}ˆ j D ]}td | | ƒdk ‘qqS )rR   r—   )r�   r    rŽ  r�  rg   rh   rÞ     r�  c                   ó6   g | ]}ˆˆ t d | d  ƒ t ˆ ƒ tddƒk‘qS ©rR   éýÿÿÿr—   ©r    r   rb   ©Úmur¢   r£   rg   rh   rÞ     ó   6 c                   ó2   g | ]}ˆˆ t d | ƒ t ˆ ƒ tddƒk‘qS r’  r”  rb   r•  rg   rh   rÞ     ó   2 c                   r‘  r’  r”  rb   ©ÚrhoÚurú   rg   rh   rÞ     r—  c                   r˜  r’  r”  rb   rš  rg   rh   rÞ     r™  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˜   rV  )Úcount)ra  rg   rh   Úprl  ó   z_check_antecedents.<locals>.prr¯   é   é   é   é   é   é   é   )r[  ÚE1ÚE2ÚE3ÚE4é   é   é   é   é   é   é   é   é    é!   é"   é#   )rÎ   rÑ   r   rð   rƒ   r�   r‚   r„   rš   r   r#   r)   rS  rW  rT   r    r   r+   r´   r%   rU   r   r7   rE  r5   r$   Ú	TypeErrorr‰  Úis_negativerY  )+rx  ry  rz   r  rK  rŸ   rÍ   rs   ÚbstarÚcstarÚphir\  rŒ  rŸ  r   Úc3Úc4Úc5Úc6Úc7Úc8Úc9Úc10Úc11Úc12Úc13Úz0ÚzosÚzsoÚc14rž  Úc14_altÚlambda_cÚc15r¥  Úlambda_sr]  r†   rd   r«  Ú
mt1_existsÚ
mt2_existsr™   rg   )ra  rx  ry  r–  r¡  r¢   r¢  r£   r›  r£  r¤  rœ  rú   rh   Ú_check_antecedentsÙ  s   00$$ÿÿ*ÿ
ÿÿ*ÿ
ÿÿ ÿÿ"ÿÿ"ÿÿ
""ÿ
ÿ"ÿ"ÿùþ€ÿ$þ.ÿ.ÿ.ÿ$$þ$þ ÿ ÿ ÿ ÿ(ÿ(ÿ(ÿ(ÿÿÿÿÿ2222 
ÿ 
ÿ,,,,6
þ6
þ0
þ0
þ.
ý0
ü6
þ6
þ0
ý0
ý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  rý   )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  ru   z_int0oo.<locals>.neg)rÎ   rÑ   rƒ   r±   r�   rø   rù   rP   )rx  ry  rz   r\  r  r¡  rß  r…  r†  rz  r{  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                   rI  )Nc                   s   g | ]}|ˆˆ   ‘qS rg   rg   )rc   rŸ   rJ  rg   rh   rÞ   ,  r  z2_rewrite_inversion.<locals>.tr.<locals>.<listcomp>rg   r  rJ  rg   rh   r  +  rL  z_rewrite_inversion.<locals>.trr   rs  Tru  )	rÎ   rÑ   rÇ   rt  rP   r�   rø   rƒ   rù   )r…   ré   rê   rz   r  rŽ   r  rt  rg   rJ  rh   Ú_rewrite_inversion&  s   (ÿrá  c                   s>  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rfd	}ntj}d	ˆ d tˆ j
Ž  tˆ j	Ž  ˆ ‰ˆ j}td
||||||	|
ˆfƒ td|ˆ|fƒ ˆ j|d ks¨|d	kr¢||ks¨t dƒ dS t ˆ jˆ j¡D ]\}}|| jrÄ||krÄt dƒ  dS q°||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 ƒ }	|r;|}
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Úexponentra  ÚwpÚwmÚwry   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                   ó   g | ]}ˆ |d  ddˆƒ‘qS r�  rg   r   ©ré  r^   rg   rh   rÞ   |  ó    z0_check_antecedents_inversion.<locals>.<listcomp>c                   s   t ‡‡ fdd„ˆjD ƒŽ S )Nc                   rê  r�  rg   r   rë  rg   rh   rÞ     rì  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�  )r£  ré  r¤  rg   rh   ÚH�  rL  z'_check_antecedents_inversion.<locals>.Hc                   ó   ˆˆˆ  dˆ  | dƒS )NrR   Trg   r�  ©r£  rè  r¤  rg   rh   ÚHp„  r¬  z(_check_antecedents_inversion.<locals>.Hpc                   rï  )NrR   Frg   r�  rð  rg   rh   ÚHm‡  r¬  z(_check_antecedents_inversion.<locals>.Hm)rS  rÑ   rÎ   Ú_check_antecedents_inversionr  r   rð   rƒ   r�   r‚   r„   r¡   ÚNaNr   r÷   rW  rò   ró   rˆ  rT   r   r+   r´   rU   )rê   rz   r  rØ   rÍ   rs   r¢   r£   r€  rš   r›  Úepsilonr÷   rŽ   rž   rí  rî  rñ  rò  ra  rg   )rê   r£  ré  rè  r¤  rz   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ê   rz   rŸ   rž   rŽ   rû   rg   rg   rh   Ú_int_inversion¬  s   ,rö  c                    s&  ddl m}m‰m}m‰  tsi attƒ t| tƒrYt	| j
|ƒ |¡\}}t|ƒdkr,dS |d }|jr?|j|ks<|jjs>dS n||krEdS ddt| j| j| j| j|| ƒfgdfS | }|  |t¡} t| tƒ}|tv �r)t| }	|	D ]·\}
}}}| j|
dd�}|�r(i }| ¡ D ]\}}tt|dd�dd�||< q‡|}t|tƒs¤| |¡}|d	kr©qqt|ttfƒs·t| |¡ƒ}t|ƒd	kr¾qqt|tƒsÇ||ƒ}g }|D ]S\}}t t| |¡ t|¡dd�|ƒ}z| |¡ t|¡}W n	 t!yó   Y qËw t"||f Ž  #t$j%t$j&t$j'¡�rqËt|j|j|j|jt|j
dd�ƒ}| (||f ¡ qË|�r(||f  S qq|�s.dS t)d
ƒ ‡ ‡fdd„}|} t*dd| ƒ}dd„ }z|| |||d	dd�\}}}|||||ƒ}W n |�yg   d}Y nw |du �r«t+ddƒ}|| j,v�r«t-| |ƒ�r«z ||  ||| ¡|||dd	d�\}}}|||||ƒ |d¡}W n |�yª   d}Y nw |du �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)Úlift)Úexponents_onlyFz)Trying recursive Mellin transform method.c                   sV   zˆ| |||ddd�W S  ˆ y*   ddl m} ˆ|tt| ƒƒƒ|||ddd� Y S w )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)Ú
as_meijergÚneedevalr   )Úsimplify)rÇ   r   rY   r   )ÚFrK  rz   Ústripr   ©rú  rø  rg   rh   Úmy_imt
  s   
ÿ
þþz_rewrite_single.<locals>.my_imtrK  zrewrite-singlec                 S  sp   t | |dd�}|d u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   ©ÚhyperexpandÚnonrepsmall)Úrewrite)	Ú_meijerint_definite_4rÇ   r  Ú_my_unpolarifyr5   rS   r   rÉ   r/  )rf   rz   r™   r  ro   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+   rw  r�   rø   rƒ   rù   r¨   r^   r~   râ   Úitemsr%   r&   rC  rV   rE  r±   rÎ   Ú
ValueErrorr	   rn   r   r/  ÚComplexInfinityÚNegativeInfinityr   rS  r  r  r¿   r  rô  r   rè   ÚNotImplementedError) rf   rz   Ú	recursiver÷  rù  rã  rÍ   Úf_rŸ   r  r€   Útermsr†   r‡   r¨   Úsubs_r;  r<  ro   r…   rê   r�  r  rK  r  r  r  r  rŽ   rm   rµ   rž   rg   r  rh   Ú_rewrite_single¼  sÜ   
ÿ(

ÿ


ÿÿÿ ÿ€	
ÿÿ

þÿ 
ÿÿþÿ
r  c                 C  s8   t | |ƒ\}}}t|||ƒ}|r|||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   rz   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 ]0\}\}}t|ˆ |ƒ}	t|ˆ |ƒ}
|	rk|
rkt	|	d	 |
d	 ƒ}|d
krk|||	d |
d |f  S q;dS )a  
    Try to rewrite ``f`` as a product of two G functions of arguments a*x**b.
    Return fac, po, g1, g2 such that f = fac*po*g1*g2, where fac is
    independent of x and po is x**s.
    Here g1 and g2 are results of _rewrite_single.
    Returns None on failure.
    c                 3  s    � | ]}t |ˆ d ƒdu V  qdS )FN)r  r  ry   rg   rh   ri   a  rj   z_rewrite2.<locals>.<genexpr>Nc                   ó&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS ©Nr   rR   )Úmaxrð   rÖ   r  ry   rg   rh   r{   g  ó   & z_rewrite2.<locals>.<lambda>c                   r  r  )r  rð   rÜ   r  ry   rg   rh   r{   h  r  c                   r  r  )r  rð   rç   r  ry   rg   rh   r{   i  s    ÿ©FTrR   Fr   )
rë   r  rí   rñ   r±   r   rò   ró   r  rT   )rf   rz   r…   ré   rê   r  r  Úfac1Úfac2rx  ry  r†   rg   ry   rh   Ú	_rewrite2X  s(   


ý€úr"  c                 C  sâ   t | ƒ} g }tt| |ƒtjhB td�D ]'}t|  ||| ¡|ƒ}|s#q| ||| ¡}t|t	t
ƒr7| |¡ q|  S |  t¡rgtdƒ tt| ƒ|ƒ}|rgt|tƒsbddlm} |t|ƒ| t¡ƒS | |¡ |rot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   rn   r2   rS  Úmeijerint_indefiniter1   rá   r±   Úsympy.simplify.radsimpr%  r
   rÛ   r+   ÚextendÚnextr   )rf   rz   ÚresultsrŽ   ro   Úrvr%  rg   rg   rh   r'  u  s.   
ÿ

ÿr'  c                   s2  t d| dˆƒ ddlm}m} t| ˆƒ}|du rd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 }	q*‡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 ofÚwrtr   )r  rt  Nz could rewrite:rR   rŸ   zmeijerint-indefinitec                   ro  )Nc                   rp  rg   rg   r   ©r›  rg   rh   rÞ   »  r  z7_meijerint_indefinite_1.<locals>.tr.<locals>.<listcomp>rg   r  r.  rg   rh   r  º  rr  z#_meijerint_indefinite_1.<locals>.trc                 s  s"   � | ]}|j o|d kdkV  qdS )r   TN)rˆ  rQ  rg   rg   rh   ri   ¼  s   €  z*_meijerint_indefinite_1.<locals>.<genexpr>)ÚplaceTru  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   Ú
_from_argsÚas_coeff_add)ro   ry   rg   rh   Ú_cleanÎ  s   z'_meijerint_indefinite_1.<locals>._clean)Úevaluater4  F)rS  rÇ   r  rt  r  r   rÉ   rÎ   rÑ   r  r³   r  rƒ   rP   r±   r�   rø   rù   Úis_extended_nonnegativer¨   rn   rô  r  r6   r_   rm   r  r5   rS   )rf   rz   r  rt  rì   r…   ré   Úglr†   ro   rû   rK  rê   rŽ   rž   r  rµ   Úfac_rŸ   r  r™   r/  r3  rB  rØ   rg   )r›  rz   rh   r&  š  sL   


4ÿ4ÿr&  c                 C  sì  t d| |||fƒ t| ƒ} |  t¡rtdƒ dS |  t¡r#tdƒ dS | |||f\}}}}tdƒ}|  ||¡} |}||krBtj	dfS g }	|tj
u r\|tjur\t|  || ¡|| | ƒS |tj
u rÔtdƒ t| |ƒ}
td|
ƒ t|
tdd	�tj	g D ]X}td
|ƒ |js‰tdƒ qzt|  ||| ¡|ƒ}|du r�tdƒ qzt|  ||| ¡|ƒ}|du r±tdƒ qz|\}}|\}}tt||ƒƒ}|dkrÉtdƒ qz|| }||f  S nÙ|tju rêt| ||tjƒ}|d  |d fS ||ftj	tjfk�rt| |ƒ}|�rt|d tƒ�r|	 |¡ n¢|S nŸ|tju �rTt| |ƒD ]:}|| dkdk�rRt d|ƒ t|  ||| ¡t|| | ƒ |ƒ}|�rRt|d tƒ�rN|	 |¡ �q|  S �q|  ||| ¡} || }d}|tju�rŠttjt|ƒ ƒ}t|ƒ}|  ||| ¡} | t|| ƒ| 9 } tj}td||ƒ td| ƒ t| |ƒ}|�r­t|d tƒ�r«|	 |¡ 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.rz   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$  )'rW  r   rn   r?   rS  rQ   r   r¨   r   rÉ   r  r/  Úmeijerint_definiterç   rÃ   r   Ú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   rz   rŽ   rž   r  Úx_Úa_Úb_r  r+  ræ   rµ   Úres1Úres2Úcond1Úcond2r†   ro   ÚsplitrÈ  r,  r%  rg   rg   rh   r9  ô  sÂ   






ì

ü
ÿÿ€

ÿ*
ÿr9  c                 C  sè   | dfg}|d d }|h}t |ƒ}||vr"||dfg7 }| |¡ t|ƒ}||vr6||dfg7 }| |¡ | tt¡rRt t|ƒƒ}||vrR||dfg7 }| |¡ | tt¡rrddl	m
} ||ƒ}||vrr||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   rn   r:   r2   r   r7   r8   Úsympy.simplify.furD  )rf   rz   ro   ÚorigÚsawÚexpandedrD  Úreducedrg   rg   rh   Ú_guess_expansion  s.   




rJ  c                 C  sj   t dd| dd�}|  ||¡} |}| dkrtjdfS t| |ƒD ]\}}td|ƒ t||ƒ}|r2|  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.
    rz   zmeijerint-definite2T)Úpositiver   ÚTryingN)r  r¨   r   rÉ   rJ  rS  Ú_meijerint_definite_3)rf   rz   Údummyrê   Úexplanationro   rg   rg   rh   r;  Ÿ  s   


ÿýr;  c                   s    t | ˆ ƒ}|r|d dkr|S | jrJtdƒ ‡ fdd„| jD ƒ}tdd„ |D ƒƒrLg }tj}|D ]\}}||7 }||g7 }q0t|Ž }|dkrN||fS dS d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                   r  rg   )r
  )rc   rê   ry   rg   rh   rÞ   É  r  z)_meijerint_definite_3.<locals>.<listcomp>c                 s  s   � | ]}|d uV  qd S r`   rg   )rc   r™   rg   rg   rh   ri   Ê  s   € z(_meijerint_definite_3.<locals>.<genexpr>N)r
  Úis_AddrS  rm   rl   r   rÉ   rT   )rf   rz   ro   Úressra  r™   rµ   rg   ry   rh   rM  ½  s$   
õrM  c                 C  s   t t| ƒƒS r`   )rE  r%   re   rg   rg   rh   r  Õ  rU  r  c              
   C  s,  ddl m} td| ƒ |sut| |dd�}|duru|\}}}}td|||ƒ tj}	|D ]0\}
}} |
dkr4q*t||
 |||  | |ƒ\}
} |	|
t| |ƒ 7 }	t|t	| |ƒƒ}|dkrZ nq*t
|ƒ}|dkrhtdƒ ntd	|	ƒ t
||	ƒƒ|fS t| |ƒ}|du�rd
D ]’}|\}}}}}td||||ƒ tj}	|D ]S\}}}|D ]J\}}}t|| | ||||   ||||ƒ}|du rÃtdƒ    dS |\}
}}td|
||ƒ t|t|||ƒƒ}|dkrÞ n|	|
t|||ƒ 7 }	qžq— t
|ƒ}|dkrùtd|ƒ q�td|	fƒ |�r|	|f  S t
||	ƒƒ|f  S dS 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  Ú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  rS  r  r   rÉ   rN  rl  rT   rY  r  r"  r‡  rÞ  rà  rW  )rf   rz   r  r  rì   r…   ré   rê   r†   ro   rû   rK  rG  rx  ry  rƒ  Ús1Úf1r„  Ús2Úf2r™   Úf1_Úf2_rg   rg   rh   r
  Ù  sj   
ÿ



ÿ

är
  c                 C  sX  | }|}t ddd�}|  ||¡} td| ƒ t| |ƒs tdƒ dS tj}| jr,t| jƒ}nt	| t
ƒr5| g}nd}|rÌg }g }|rÄ| ¡ }	t	|	t
ƒr}t|	ƒ}
|
jrU||
j7 }q=zt|	jd |ƒ\}}W n tyl   d}Y nw |dkrw| |¡ nK| |	¡ nE|	jr½t|	ƒ}
|
jr�||
j7 }q=||	jjvr·z
t|	j
|ƒ\}}W n ty¨   d}Y nw |dkr·| |t|	jƒ ¡ | |	¡ n| |	¡ |s?t|Ž }t|Ž } || jv�rtd	| |ƒ tt|ƒdƒ}|d
krétdƒ dS | t|| ƒ }td||ƒ t| ||¡|fƒS t| |ƒ}|du�rª|\}}}}td|||ƒ tj}|D ].\}}} t|| |||  | |ƒ\}} ||t| ||ƒ 7 }t|t| |ƒƒ}|d
k�rJ n�qt|ƒ}|d
k�r[tdƒ dS td|ƒ ddl m!} t||ƒƒ}| "t#¡�sx|t#|ƒ9 }| ||| ¡}t	|t$ƒ�sŽ| ||| ¡}ddl%m&} t| ||¡|f|| ||¡||dƒdfƒS dS )aê  
    Compute the inverse laplace transform
    $\int_{c+i\infty}^{c-i\infty} f(x) e^{tx}\, dx$,
    for real c larger than the real part of all singularities of ``f``.

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

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

    Examples
    ========

    >>> from sympy.abc import x, t
    >>> from sympy.integrals.meijerint import meijerint_inversion
    >>> meijerint_inversion(1/x, x, t)
    Heaviside(t)
    rŸ   Tru  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:rS  rT  z"Result before branch substitution:r  )ÚInverseLaplaceTransform)'r   r¨   rS  r  r   rÉ   Úis_Mulr±   rm   rá   r+   Úpopr   rÎ   rÄ   r   rÊ   rË   r¿   r-   r   r   r   r!   r?   r5   r  rá  rö  rT   ró  r  rÇ   r  rn   r@   rC  r  r[  )rf   rz   rŸ   r  Út_Úshiftrm   rB  Úexponentialsr"   r@  rŽ   rž   r†   ro   rì   r…   ré   rê   rû   rK  r  r[  rg   rg   rh   Úmeijerint_inversion!  s®   




ÿ
ÿ
ã


ÿ

ÿéra  )rf   r   rz   r   r¸   r¹   r°   )F)²rÅ   Ú
__future__r   rò   Úsympyr   Ú
sympy.corer   r   Úsympy.core.addr   Úsympy.core.basicr   Úsympy.core.cacher   Úsympy.core.containersr	   Úsympy.core.exprtoolsr
   Úsympy.core.functionr   r   r   r   r   Úsympy.core.mulr   Úsympy.core.intfuncr   Úsympy.core.numbersr   r   Úsympy.core.relationalr   r   r   Úsympy.core.sortingr   r   Úsympy.core.symbolr   r   r   r   Úsympy.core.sympifyr   Ú(sympy.functions.combinatorial.factorialsr   Ú$sympy.functions.elementary.complexesr    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   Ú&sympy.functions.elementary.exponentialr+   r,   r-   Ú#sympy.functions.elementary.integersr.   Ú%sympy.functions.elementary.hyperbolicr/   r0   r1   r2   Ú(sympy.functions.elementary.miscellaneousr4   Ú$sympy.functions.elementary.piecewiser5   r6   Ú(sympy.functions.elementary.trigonometricr7   r8   r9   r:   Úsympy.functions.special.besselr;   r<   r=   r>   Ú'sympy.functions.special.delta_functionsr?   r@   Ú*sympy.functions.special.elliptic_integralsrA   rB   Ú'sympy.functions.special.error_functionsrC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   Ú'sympy.functions.special.gamma_functionsrN   Úsympy.functions.special.hyperrO   rP   Ú-sympy.functions.special.singularity_functionsrQ   Ú	integralsrS   Úsympy.logic.boolalgrT   rU   rV   rW   rX   Úsympy.polysrY   rZ   Úsympy.utilities.iterablesr[   Úsympy.utilities.miscr\   rS  r]   rW  r^   ra   r¶   Úsympy.utilities.timeutilsr·   Útimeitr~   r  rÄ   rÎ   rÖ   rÜ   rç   rë   rí   rñ   rü   r  r  r  Ú__annotations__r  r  r  r  rE  rH  rN  rY  rl  r‡  rÞ  rà  rá  ró  rö  r  r  r  r"  r'  r&  r9  rJ  r;  rM  r  r
  ra  rg   rg   rg   rh   Ú<module>   s¼    44	 R
"!$'	

{

p
I  2z 
%Z
  G