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© úl/var/www/html/academy/tools/voices/clone/cosy-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>.wildZ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%   rw   )Ú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   ry   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. ry   útype[Basic]r·   útuple[int, int, str]c                 S  s   |   ¡ S r`   )Ú	class_keyrx   rg   rg   rh   Úkey/  s   z_mytype.<locals>.keyrg   c                 3  s$   � | ]}t |ˆ ƒD ]}|V  q	qd S r`   )r}   )rc   r�   rž   rx   rg   rh   ri   6  s   €" z_mytype.<locals>.<genexpr>©r¼   N)ry   r¹   r·   rº   )Úfree_symbolsÚis_FunctionÚtypeÚtupleÚsortedrm   )rf   ry   r¼   rg   rx   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²   )Úexprry   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Ë   ry   ro   Úargument©Ú_exponents_rg   rh   rÒ   u  s   
ÿz_exponents.<locals>._exponents_©Úset)rË   ry   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   Úerx   rg   rh   Ú	<setcomp>…  ó    z_functions.<locals>.<setcomp>)Úatomsr   )rË   ry   rg   rx   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   rx   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 rv   )Ú
isinstancer   Úmatchr‰   Úis_Atomrm   )rË   ro   rÌ   rÐ   ©Úcompute_innermostr¡   r¢   ry   rg   rh   rä   œ  s   

ÿz1_find_splitting_points.<locals>.compute_innermostrÓ   )rË   ry   Ú	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   ry   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+   rw   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   ry   Ú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Ë   rx   rg   rh   ri   X  s   € z_is_analytic.<locals>.<genexpr>)ÚanyrÚ   r@   r#   )rf   ry   rg   rx   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   rz   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   ry   )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)ÚrelZLHSrÌ   )r¡   r¢   rg   rh   Úrel_touchupÂ  s   z_condsimp.<locals>.rel_touchupc                 S  r  r`   r  r  rg   rg   rh   rz   Ñ  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ÚchangeZiruleÚfroÚtors   Úarg1ÚnumZ	otherargsÚarg2r   Zarg3Únewargsr0  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   
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   )ry   rí   rg   rg   rh   rz   é  s    z&_my_principal_branch.<locals>.<lambda>)r(   r1  )rË   ÚperiodÚfull_pbro   rg   rg   rh   Ú_my_principal_branchá  s   
rC  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  rE  rg   rh   r  ü  ó   z_rewrite_saxena_1.<locals>.tr)
rÍ   rÐ   Ú
get_periodrC  r#   rP   r€   r÷   r‚   rø   )	r„   rè   ré   ry   r  r�   rA  rú   r  rg   rE  rh   Ú_rewrite_saxena_1í  s   
 $ÿrI  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þ   rK  rÿ   rg   rg   rh   rÝ     rÙ   c                 S  rJ  rþ   rK  rL  rg   rg   rh   rÝ     rÞ   c                 S  rM  rþ   rK  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é   ry   Úhelperrö   Úetar  rÌ   rs   r¡   r¢   r  ÚtmpZcond_3Zcond_3_starZcond_4r\   r]   ÚcondsZcase1Ztmp1Ztmp2Ztmp3r   Úextrarž   Zcase2Zcase3Z
case_extrarF  r�   r�   Zcase_extra_2rg   rg   rh   rT    sš   0ÿþ $ÿ8&
ÿ
ÿ
*
ÿ6
,

 

rT  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Æ   r[  rÍ   rÐ   r‚   rN   r€   rø   r÷   r%   )ré   ry   r[  rW  r  ro   r�   r�   rg   rg   rh   Ú	_int0oo_1r  s   



r\  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Ð   rH  rP   r€   r÷   r‚   rø   rC  )ré   r�   r�   Úper)rB  ry   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  ra  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Æ   rd  )r„   rè   Úg1Úg2ry   rB  r^  r  rF  Úb1Úb2Úm1Ún1Úm2Ún2ÚtauÚr1Úr2ÚC1ÚC2Úa1r�   Úa2r  rd  rg   )r+   rB  ry   rh   Ú_rewrite_saxena�  s>   ,rw  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)rh  ri  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   rz  ©ri  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—   rQ  )Úcount)rY  rg   rh   Úprl  ó   z_check_antecedents.<locals>.prr®   é   é   é   é   é   é   é   )rV  ÚE1ÚE2ÚE3ÚE4é   é   é   é   é   é   é   é   é    é!   é"   é#   )rÍ   rÐ   r   rï   r‚   r€   r�   rƒ   r™   r   r#   r)   rN  rR  rT   r    r   r+   r³   r%   rU   r   r7   r@  r5   r$   Ú	TypeErrorry  Úis_negativerT  )+rh  ri  ry   r  rF  rž   rÌ   rs   ZbstarZcstarÚphirW  r|  r�  r�  Úc3Úc4Zc5Zc6Zc7Úc8Zc9Zc10Zc11Zc12Zc13Úz0ZzosZzsoZc14rŽ  Zc14_altZlambda_cZc15r•  Zlambda_srX  r…   rd   r›  Z
mt1_existsZ
mt2_existsr˜   rg   )rY  rh  ri  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   )rh  ri  ry   rW  r  r‘  r¼  ru  rv  rj  rk  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                   rD  )Nc                   s   g | ]}|ˆˆ   ‘qS rg   rg   )rc   rž   rE  rg   rh   rÝ   ,  r  z2_rewrite_inversion.<locals>.tr.<locals>.<listcomp>rg   r  rE  rg   rh   r  +  rG  z_rewrite_inversion.<locals>.trr   rc  Tre  )	rÍ   rÐ   rÆ   rd  rP   r€   r÷   r‚   rø   )r„   rè   ré   ry   r  r�   r  rd  rg   rE  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ÚexponentrY  ÚwpZwmÚwrx   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�  rG  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)rN  rÐ   rÍ   Ú_check_antecedents_inversionr  r   rï   r‚   r€   r�   rƒ   r    ÚNaNr   rö   rR  rñ   rò   rx  rT   r   r+   r³   rU   )ré   ry   r  r×   rÌ   rs   r¡   r¢   rp  r™   r‹  Úepsilonrö   r�   r�   rÉ  rÊ  rÍ  rÎ  rY  rg   )ré   r“  rÅ  rÄ  r”  ry   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é   ry   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)Z
as_meijergÚneedevalr   )Úsimplify)rÆ   rÛ  rY   r   )ÚFrF  ry   ÚstriprÛ  ©rÖ  rÔ  rg   rh   Úmy_imt
  s   
ÿ
þþz_rewrite_single.<locals>.my_imtrF  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   ©ÚhyperexpandZnonrepsmall)Úrewrite)	Ú_meijerint_definite_4rÆ   râ  Ú_my_unpolarifyr5   rS   r   rÈ   r.  )rf   ry   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+   rg  r€   r÷   r‚   rø   r§   r^   r}   rá   Úitemsr%   r&   r>  rV   r@  r°   rÍ   Ú
ValueErrorr	   rn   r   r.  ÚComplexInfinityÚNegativeInfinityr~   rN  r  r  r¾   r  rÐ  r   rç   ÚNotImplementedError) rf   ry   Ú	recursiverÓ  rÕ  rÀ  rÌ   Úf_rž   r  r   Útermsr…   r†   r§   Zsubs_r8  r9  ro   r„   ré   rq  rß  rF  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   ry   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  rx   rg   rh   ri   a  rj   z_rewrite2.<locals>.<genexpr>Nc                   ó&   t tt| d ˆ ƒƒtt| d ˆ ƒƒƒS ©Nr   rR   )Úmaxrï   rÕ   r  rx   rg   rh   rz   g  ó   & z_rewrite2.<locals>.<lambda>c                   rô  rõ  )rö  rï   rÛ   r  rx   rg   rh   rz   h  r÷  c                   rô  rõ  )rö  rï   ræ   r  rx   rg   rh   rz   i  s    ÿ©FTrR   Fr   )
rê   r  rì   rð   r°   r   rñ   rò   rò  rT   )rf   ry   r„   rè   ré   r  rï  Zfac1Úfac2rh  ri  r…   rg   rx   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   rN  Úmeijerint_indefiniter1   rà   r°   Úsympy.simplify.radsimprý  r
   rÚ   r+   ÚextendÚnextr   )rf   ry   Ú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â  rd  Nz could rewrite:rR   rž   zmeijerint-indefinitec                   r_  )Nc                   r`  rg   rg   rÿ   ©r‹  rg   rh   rÝ   »  r   z7_meijerint_indefinite_1.<locals>.tr.<locals>.<listcomp>rg   r  r  rg   rh   r  º  rb  z#_meijerint_indefinite_1.<locals>.trc                 s  s"   � | ]}|j o|d kdkV  qdS )r   TN)rx  rL  rg   rg   rh   ri   ¼  s   €  z*_meijerint_indefinite_1.<locals>.<genexpr>)ÚplaceTre  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   rx   rg   rh   Ú_cleanÎ  s   z'_meijerint_indefinite_1.<locals>._clean)Úevaluater  F)rN  rÆ   râ  rd  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   ry   râ  rd  rë   r„   rè   Úglr…   ro   rú   rF  ré   r�   r�   r  r´   Zfac_rž   r  r˜   r  r  r=  r×   rg   )r‹  ry   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.ry   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ü  )'rR  r   rn   r?   rN  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   ry   r�   r�   rð  Zx_Úa_Zb_r  r  rå   r´   Úres1Úres2Úcond1Úcond2r…   ro   Úsplitr¶  r  rý  rg   rg   rh   r  ô  sÂ   






ì

ü
ÿÿ€

ÿ*
ÿr  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.fur  )rf   ry   ro   ÚorigÚsawÚexpandedr  Úreducedrg   rg   rh   Ú_guess_expansion  s.   




r  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.
    ry   zmeijerint-definite2T)Úpositiver   ZTryingN)r  r§   r   rÈ   r  rN  Ú_meijerint_definite_3)rf   ry   Údummyré   Z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é   rx   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_AddrN  rm   rl   r   rÈ   rT   )rf   ry   ro   ZressrY  r˜   r´   rg   rx   rh   r!  ½  s$   
õr!  c                 C  s   t t| ƒƒS r`   )r@  r%   re   rg   rg   rh   rå  Õ  rP  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á  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â  rN  ró  r   rÈ   rI  r\  rT   rT  rå  rú  rw  r»  r½  rR  )rf   ry   rà  râ  rë   r„   rè   ré   r…   ro   rú   rF  rB  rh  ri  rs  Ús1Úf1rt  Ús2Úf2r˜   Zf1_Z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ž   Tre  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§   rN  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@   r>  rè  r*  )rf   ry   rž   rð  Út_Úshiftrm   r=  Zexponentialsr"   r<  r�   r�   r…   ro   rë   r„   rè   ré   rú   rF  râ  r*  rg   rg   rh   Úmeijerint_inversion!  s®   




ÿ
ÿ
ã


ÿ

ÿér/  )rf   r   ry   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   Z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\   rN  r]   rR  r^   ra   rµ   Zsympy.utilities.timeutilsr¶   Útimeitr}   rë  rÃ   rÍ   rÕ   rÛ   ræ   rê   rì   rð   rû   r  r  r
  Ú__annotations__r  r  r  r  r@  rC  rI  rT  r\  rw  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