B
    [ç. ă               @   sÔ  d 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mZmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ ddlmZmZmZ ddlmZ ddl m!Z!m"Z"m#Z# ddl$m%Z%m&Z& ddl'm(Z( ddl)m*Z*m+Z+ ddl,m-Z-m.Z. ddl/m0Z0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6 ddl7m8Z9 ddl:m;Z; edZ<dd Z=dd Z>ddl?m@Z@ e@dZAdd ZBG d d! d!eCZDd"d# ZEd$d% ZFd&d' ZGd(d) ZHd*d+ ZId,d- ZJd.d/ ZKd0d1 ZLd2d3 ZMd4d5 ZNi aOd6d7 ZPd8d9 ZQd:d; ZRd<d= ZSd>d? ZTdodAdBZUdCdD ZVdpdEdFZWdGdH ZXdqdIdJZYdKdL ZZdMdN Z[dOdP Z\dQdR Z]dSdT Z^dUa_eeAdrdWdXZ`dsdYdZZad[d\ Zbd]d^ Zcd_d` ZdeAdadb Zedcdd Zfdedf Zgdgdh Zhdidj ZieAdtdkdlZjdmdn ZkdUS )uaż  
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
é    )Úprint_functionÚdivision)ÚooÚSÚpiÚExpr)Úfactor_terms)ÚexpandÚ
expand_mulÚexpand_power_base)ÚAdd)ÚMul)Úrange)Úcacheit)ÚDummyÚWild)ÚhyperexpandÚ	powdenestÚcollect)Úsincos_to_sum)ÚAndÚOrÚBooleanAtom)Ú
DiracDeltaÚ	Heaviside)Úexp)Ú	PiecewiseÚpiecewise_fold)Ú_rewrite_hyperbolics_as_expÚHyperbolicFunction)ÚcosÚsin)Úmeijerg)Úmultiset_partitionsÚordered)Údebug)Údefault_sort_keyÚzc                s6   t | } t| ddr,t fdd| jD S | j  S )NÚis_PiecewiseFc             3   s   | ]}t |f  V  qd S )N)Ú_has)Ú.0Úi)ÚfŠ ú8lib/python3.7/site-packages/sympy/integrals/meijerint.pyú	<genexpr>=   s    z_has.<locals>.<genexpr>)r   ÚgetattrÚallÚargsÚhas)Úresr,   r-   )r,   r.   r)   8   s    r)   c       &         s
  dd }t t|d\
}tddd gdt
  tdd	d	ffd
d	d,fdd	}dd }|d	d	fgd< ddlmm}m} G fddd|}ddlm	}m
	m}	m}
m}m}m}mm}m}mm}m}m}m}m} t  d   gg g dg |d   tdk t  d   g gdgg  |d   tdk tt d
    d   gg g dg |d   tdk t d
  t  d   g gdgg  |d   tdk    d gg dgg    | ||d t   d gd d gdgd d g d|	 d  |d  t   |dk       dgg dgg  d  |	  	  	fdd  fdd}|dd |dd |tdd d |tdd d  
fdd}|dd |dd |tdd d |tdd d |
|d g g dgg  |g dgtdd gddgd d 	tdd   |g tdd gdgtdd tdd gd d 	tdd   |g g tdd gdgd d 	 |	g g dgtdd gd d 	 |g g dgtdd gd d 	d  fd d!fd"d#|| td  d	 || td  d	 fd$d%}|| |d	 || ||tdtddgg dgdg fg d	 ||t ||t	tddgtdd gdgdtdd g fg d	 dd&lm}m}m}m }m!}m"}m#}m$}m%} |||| 	 tdtg dgddgg |d fg d	 |dgg tdd gddgd d 	d  |g dgddgtdd gd d 	 d  |tdd gg dgtdd tdd g|dd  d 	 d  |g tdd dgddgtdd tdd gd d 	td'  d  |g gd dgg  |dgg tdd gdgd d	  |g dgdtdd gg d d	  |tdd gg dgtd d gd  	  |dgg tdd gdtdd g	d d  d( tdd  |dgg tdd gdtdd g	d d  d( tdd  dd)lm&} m'}!m(}"m)}# | g g d g d gd d  |!g d  d gd  d gd  d gd d  |"g d d gd g d d d gd d 	 |#g g d  d gg d d tdd  dd*lm*}$m+}% |$tj,tj,gg dgdg tj, |%tj,dtj, gg dgdg tj, d  d+S )-z8 Add formulae for the function -> meijerg lookup table. c             S   s   t | tgdS )N)Úexclude)r   r'   )Únr-   r-   r.   ÚwildC   s    z"_create_lookup_table.<locals>.wildZpqabcr6   c             S   s   | j o| dkS )Nr   )Ú
is_Integer)Úxr-   r-   r.   Ú<lambda>F   s    z&_create_lookup_table.<locals>.<lambda>)Z
propertiesé   Tc	       	   
      s6      t| tg Ą | |t|||||fg||fĄ d S )N)Ú
setdefaultÚ_mytyper'   Úappendr"   )	ÚformulaÚanÚapÚbmÚbqÚargÚfacÚcondÚhint)Útabler-   r.   ÚaddI   s    z!_create_lookup_table.<locals>.addc                s$      t| tg Ą | |||fĄ d S )N)r<   r=   r'   r>   )r?   ZinstrF   rG   )rH   r-   r.   ÚaddiM   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 )Nr;   r   )r"   r'   )Úar-   r-   r.   ÚconstantQ   s    z&_create_lookup_table.<locals>.constantr-   r   )Ú
unpolarifyÚFunctionÚNotc                   s   e Zd Ze fddZdS )z2_create_lookup_table.<locals>.IsNonPositiveIntegerc                s    |}|j dkr|dkS d S )NTr   )r8   )ÚclsrD   )rM   r-   r.   Úeval\   s    
z7_create_lookup_table.<locals>.IsNonPositiveInteger.evalN)Ú__name__Ú
__module__Ú__qualname__ÚclassmethodrQ   r-   )rM   r-   r.   ÚIsNonPositiveIntegerZ   s   rV   )Úgammar   r    r   Úrer!   ÚsincÚsqrtÚsinhÚcoshÚ	factorialÚlogÚerfÚerfcÚerfiÚ
polar_lift)rG   é   c                s,    t d d  | | d dd|     S )Nr;   rc   )r   )ÚrÚsignÚnu)r   r-   r.   ÚA1v   s    z _create_lookup_table.<locals>.A1c                s   d  |   d  |   d d dd|   d  gg |  d g|  d gd  d|     | |  d S )Nrc   r;   r-   )rd   Úsgn)rg   rK   rI   ÚbrZ   Útr-   r.   Útmpaddy   s    , *z$_create_lookup_table.<locals>.tmpaddé˙˙˙˙c                sŹ   t    | t d     t    |   d|  | d  gd|  | d  gdtdd gg t    d |    | |  d S )Nrc   r;   r   )r'   r   )rd   rh   )rg   rK   rI   ri   ÚpÚqrZ   r-   r.   rk      s    D8é   é   c                s>   |  }d|  | t g dg|d  dg|d  g fgS )Nrl   r;   r   )r"   )ÚsubsÚN)r]   r6   rj   r-   r.   Ú	make_log1    s    z'_create_lookup_table.<locals>.make_log1c                s6   |  } |t dg|d  g g dg|d  fgS )Nr;   r   )r"   )rq   rr   )r]   r6   rj   r-   r.   Ú	make_log2Ľ   s    z'_create_lookup_table.<locals>.make_log2c                s    | |  S )Nr-   )rq   )rs   rt   r-   r.   Ú	make_log3Ż   s    z'_create_lookup_table.<locals>.make_log3)	ÚEiÚIÚexpintÚSiÚCiÚShiÚChiÚfresnelsÚfresnelcz3/2é   )ÚbesseljÚbesselyÚbesseliÚbesselk)Ú
elliptic_kÚ
elliptic_eN)T)-ÚlistÚmapr   r'   r   ÚsympyrM   rN   rO   rW   r   r    r   rX   r!   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   r   r   Úabsr"   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r   r   r   r   r   ZHalf)&rH   r7   ÚcrJ   rL   rN   rO   rV   rW   r    r   rX   r!   rY   r[   r\   r^   r_   r`   ra   rb   rk   ru   rv   rw   rx   ry   rz   r{   r|   r}   r~   r   r   r   r   r   r   r-   )rg   rK   rI   ri   r]   rs   rt   r6   rm   r   rn   rZ   rj   rH   rM   r.   Ú_create_lookup_tableA   s    	H. . : : 4<:.



<L004  06	,"8:B>"22>HH.FD8(r   )Útimethisr"   c                sd    | j krdS | jrt| fS  fdd| jD }g }x|D ]}|t|7 }q<W | Ą  t|S dS )z4 Create a hashable entity describing the type of f. r-   c                s   g | ]}t | qS r-   )r=   )r*   rK   )r9   r-   r.   ú
<listcomp>&  s    z_mytype.<locals>.<listcomp>N)Úfree_symbolsZis_FunctionÚtyper2   r   ÚsortÚtuple)r,   r9   Útypesr4   rj   r-   )r9   r.   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)rR   rS   rT   Ú__doc__r-   r-   r-   r.   r   .  s   r   c             C   s~   ddl m} t||  |Ą\}}|s2|tdfS |\}|jrZ|j|krPtd||jfS ||krn|tdfS td|  dS )aq  
    When expr is known to be of the form c*x**b, with c and/or b possibly 1,
    return c, b.

    >>> 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**br;   zexpr not of form a*x**b: %sN)	r   r   r   Úas_coeff_mulr   Úis_PowÚbaser   r   )Úexprr9   r   r   Úmr-   r-   r.   Ú_get_coeff_exp5  s    

r   c                s"    fdd t  } | || |S )at  
    Find the exponents of ``x`` (not including zero) in ``expr``.

    >>> from sympy.integrals.meijerint import _exponents
    >>> from sympy.abc import x, y
    >>> from sympy import sin
    >>> _exponents(x, x)
    {1}
    >>> _exponents(x**2, x)
    {2}
    >>> _exponents(x**2 + x, x)
    {1, 2}
    >>> _exponents(x**3*sin(x + x**y) + 1/x, x)
    {-1, 1, 3, y}
    c                sZ   | |kr|  dgĄ d S | jr:| j|kr:|  | jgĄ d S x| jD ]} ||| qBW d S )Nr;   )Úupdater   r   r   r2   )r   r9   r4   rD   )Ú_exponents_r-   r.   r   d  s    z_exponents.<locals>._exponents_)Úset)r   r9   r4   r-   )r   r.   Ú
_exponentsT  s    	r   c                s(   ddl m} t fdd|  |ĄD S )zB Find the types of functions in expr, to estimate the complexity. r   )rN   c             3   s   | ]} |j kr|jV  qd S )N)r   Úfunc)r*   Úe)r9   r-   r.   r/   u  s    z_functions.<locals>.<genexpr>)r   rN   r   Úatoms)r   r9   rN   r-   )r9   r.   Ú
_functionsr  s    rŁ   c                s<   fdddD \ fdd t  } | | |S )aX  
    Find numbers a such that a linear substitution x -> x + a would
    (hopefully) simplify expr.

    >>> from sympy.integrals.meijerint import _find_splitting_points as fsp
    >>> from sympy import sin
    >>> from sympy.abc import a, 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 ))r5   )r   )r*   r6   )r9   r-   r.   r     s    z*_find_splitting_points.<locals>.<listcomp>Zpqc                st   t | tsd S |    Ą}|rL| dkrL| |  |  Ą d S | jrVd S x| jD ]} || q^W d S )Nr   )Ú
isinstancer   ÚmatchrI   Zis_Atomr2   )r   r4   r   rD   )Úcompute_innermostrm   rn   r9   r-   r.   rŚ     s    
z1_find_splitting_points.<locals>.compute_innermost)r   )r   r9   Ú	innermostr-   )rŚ   rm   rn   r9   r.   Ú_find_splitting_pointsx  s
    
r¨   c             C   sô   ddl m}m} td}td}td}t| } t | Ą}xŽ|D ]Ś}||krV||9 }q@||jkrj||9 }q@|jrŢ||j	jkrŢ|j
 |Ą\}	}
|
|fkrŞt|j
 |Ą\}	}
|
|fkrŢ|||j	 9 }||||	|j	 dd9 }q@||9 }q@W |||fS )aV  
    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".

    >>> 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))
    r   )ÚpolarifyrM   r;   F)rq   )r   rŠ   rM   r   r   r   Ú	make_argsr   r   r   r   r   r
   )r,   r9   rŠ   rM   rE   ÚpoÚgr2   rK   r   rj   r-   r-   r.   Ú
_split_mul  s*    






r­   c             C   sj   t  | Ą}g }xV|D ]N}|jrX|jjrX|j}|j}|dk rH| }d| }||g| 7 }q| |Ą qW |S )zĚ
    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   r;   )r   rŞ   r   r   r8   r   r>   )r,   r2   ÚgsrŹ   r6   r   r-   r-   r.   Ú	_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.

    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.

    >>> 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))]
    rc   Nc             S   s    g | ]\}}t | t | fqS r-   )r   )r*   r9   Úyr-   r-   r.   r   ë  s    z%_mul_as_two_parts.<locals>.<listcomp>)rŻ   Úlenr   r#   )r,   rŽ   r-   r-   r.   Ú_mul_as_two_partsŐ  s    
r˛   c          
   C   s   dd }t t| jt| j }|d| j |d   }|dt |d | j   }|t|| j||| j	||| j
||| j|| j| |||   fS )zO Return C, h such that h is a G function of argument z**n and
        g = C*h. c             S   s:   g }x0| D ](}x"t |D ]}| || | Ą qW q
W |S )z5 (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) )r   r>   )Zparamsr6   r4   rK   r+   r-   r-   r.   Úinflateó  s
    
z_inflate_g.<locals>.inflater;   rc   )r   rą   rA   rC   rf   r   Údeltar"   r@   ÚaotherrB   ÚbotherÚargument)rŹ   r6   rł   ÚvÚCr-   r-   r.   Ú
_inflate_gî  s    rş   c             C   s6   dd }t || j|| j|| j|| jd| j S )zQ Turn the G function into one of inverse argument
        (i.e. G(1/x) -> G'(x)) c             S   s   dd | D S )Nc             S   s   g | ]}d | qS )r;   r-   )r*   rK   r-   r-   r.   r     s    z'_flip_g.<locals>.tr.<locals>.<listcomp>r-   )Úlr-   r-   r.   Útr  s    z_flip_g.<locals>.trr;   )r"   rB   rś   r@   rľ   rˇ   )rŹ   rź   r-   r-   r.   Ú_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 )aX  
    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   rc   r;   c                s   g | ]}|d    qS )r;   r-   )r*   r6   )rm   r-   r.   r   !  s    z"_inflate_fox_h.<locals>.<listcomp>)Ú_inflate_fox_hr˝   r   rm   rn   rş   rˇ   r   r   r"   r@   rľ   rB   r   rś   )rŹ   rK   rn   ÚDr'   Zbsr-   )rm   r.   rž     s    

*rž   c             K   s(   t | |f|}||jkr$t| f|S |S )zś
    Return a dummy. This will return the same dummy if the same token+name is
    requested more than once, and it is not already in expr.
    This is for being cache-friendly.
    )Ú_dummy_r   r   )ÚnameÚtokenr   ÚkwargsÚdr-   r-   r.   Ú_dummy'  s    
rĹ   c             K   s,   | |ft kr t| f|t | |f< t | |f S )z`
    Return a dummy associated to name and token. Same effect as declaring
    it globally.
    )Ú_dummiesr   )rÁ   rÂ   rĂ   r-   r-   r.   rŔ   3  s    rŔ   c                s0   ddl m}m} t fdd|  ||Ą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 r   )r   ÚAbsc             3   s   | ]} |j kV  qd S )N)r   )r*   r   )r9   r-   r.   r/   B  s    z_is_analytic.<locals>.<genexpr>)r   r   rÇ   Úanyr˘   )r,   r9   r   rÇ   r-   )r9   r.   Ú_is_analytic>  s    rÉ   c                sö  ddl m}m}m}mm}m}m}m m	m
m ddlm} t| |sN| S | jttt| j } d}|d|d\}	tk |kftt |kt d|  |k| | dfttd  | |ktd  | |k| dftt|kt|d| |  |k||| |  dftt|d kt|| |  |d k||| | d  dftktk |	kfg}
xú|rĚd	}xć|
D ]Ü\}}|j| jkrqćxźt| jD ]Ź\}}|	|jd jkrB| |jd
 Ąd
}nd}| |jd Ąs`qfdd|jd| |j|d
 d  D }|gxŘ|D ]Đ}xČt| jD ]ş\}}|krŔqŞ||krÖ|g7 P t|tr|jd
 |	krt|tr|jd |jkr|g7 P t|trŞ|jd |	krŞt|trŞ|jd
 |jkrŞ|g7 P qŞW qW tt|d
 krqfddt| jD | Ąg }| j| } d}P qW qćW qÔW  fdd}|  dd |ĄS )aŇ  
    Do naive simplifications on ``cond``.

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

    >>> from sympy.integrals.meijerint import _condsimp as simp
    >>> from sympy import Or, Eq, unbranched_argument as arg, And
    >>> from sympy.abc import x, y, z
    >>> simp(Or(x < y, z, Eq(x, y)))
    z | (x <= y)
    >>> simp(Or(x <= y, And(x < y, z)))
    x <= y
    r   )Úsymbolsr   ÚEqÚunbranched_argumentÚ	exp_polarr   rw   rD   Úperiodic_argumentr   rb   )ÚBooleanFunctionTzp q r)rP   rc   éţ˙˙˙Fr;   c                s   g | ]}|   ĄqS r-   )rq   )r*   r9   )r   r-   r.   r   {  s    z_condsimp.<locals>.<listcomp>Nc                s   g | ]\}}| kr|qS r-   r-   )r*   ÚkÚarg_)Ú	otherlistr-   r.   r     s    c                s   | j dkr| j}n| jdkr$| j }n| S |   Ą}|sT|  Ą}|st|r|jd js|jd kr|jd dkS | S | dkS )Nr   r;   )ZlhsZrhsrĽ   r¤   r2   Zis_polar)Úorigr   r   )rD   r   rm   rÎ   rb   rn   rĚ   r-   r.   Úrepl_eq  s    

z_condsimp.<locals>.repl_eqc             S   s   | j o| jdkS )Nz==)Zis_RelationalZrel_op)r   r-   r-   r.   r:   Ś  s    z_condsimp.<locals>.<lambda>)r   rĘ   r   rË   rĚ   rÍ   r   rw   rD   rÎ   r   rb   Úsympy.logic.boolalgrĎ   r¤   r    r   r   Ú	_condsimpr2   r   r   r   Ú	enumerater   rĽ   rą   rq   Úreplace)rF   rĘ   r   rË   rÍ   r   rw   rĎ   Zchangerd   ZrulesÚfroÚtor6   Zarg1ZnumZ	otherargsÚarg2rŃ   Zarg3ÚnewargsrŐ   r-   )	rD   r   r   rÓ   rm   rÎ   rb   rn   rĚ   r.   r×   E  sx    4
(0 " "
.






r×   c             C   s   t | tr| S t|  Ą S )z Re-evaluate the conditions. )r¤   Úboolr×   Zdoit)rF   r-   r-   r.   Ú
_eval_condŞ  s    
rß   Fc             C   s.   ddl m} || |}|s*| |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. r   )Úprincipal_branchc             S   s   | S )Nr-   )r9   r°   r-   r-   r.   r:   ž  s    z&_my_principal_branch.<locals>.<lambda>)r   rŕ   rŮ   )r   ÚperiodÚfull_pbrŕ   r4   r-   r-   r.   Ú_my_principal_branchľ  s
    
ră   c       	         s   t ||\}t |j|\} | Ą }t||}| t |d   d    } fdd}|t||j||j||j||j	|| fS )z
    Rewrite the integral fac*po*g dx, from zero to infinity, as
    integral fac*G, where G has argument a*x. Note po=x**s.
    Return fac, G.
    r;   c                s    fdd| D S )Nc                s    g | ]}|d     d  qS )r;   r-   )r*   rK   )ri   Úsr-   r.   r   Ň  s    z1_rewrite_saxena_1.<locals>.tr.<locals>.<listcomp>r-   )rť   )ri   rä   r-   r.   rź   Ń  s    z_rewrite_saxena_1.<locals>.tr)
r   rˇ   Ú
get_periodră   r   r"   r@   rľ   rB   rś   )	rE   rŤ   rŹ   r9   Ú_rK   rá   rš   rź   r-   )ri   rä   r.   Ú_rewrite_saxena_1Â  s    
 $rç   c       &   
   C   sô  ddl m}m}m}m}m}m} | j}	t| j	|\}
}t
t| jt| jt| jt| jg\}}}}|| | }||kr´dd }tt|| j|| j|| j|| j||
 |S g }x"| jD ]}||| dk g7 }qŔW x$| jD ]}|dd|| k g7 }qäW t| }x$| jD ]}||| dk g7 }qW x&| jD ]}|dd|| k g7 }q8W t| }|| j |d | d  || k}dd }|d	 |d
|	|
||||f  |dt| jt| jf  |dt| jt| jf  |d|||f  g }g }d|k||k d|kg}d|kd|k|||d |t||d|||d g}d|k|||g}xBt||	d d D ]*}||t||
|	d|  t g7 }qtW |	dkt||
|	t k g}||
d|g}|rÖg }x*|||gD ]} |t| | |  g7 }qâW ||7 }|d| |g}|r$g }t||d|d |k||kt||
|	t k f| g}!||!7 }|d|! ||g}|rg }t||k d|k|	dk|t||
|	t f| g}"|"t||d k||	d|t||
df| g7 }"||"7 }|d|" g }#|#|||||	d|||
d||
dg7 }#|s:|#|g7 }#g }$x*t| j| jD ]\}}|$|| g7 }$qNW |#|t|$ dk g7 }#t|# }#||#g7 }|d|#g t|	dkt||
|	t k g}%|sÎ|%|g7 }%t|% }%||%g7 }|d|%g t| S )aL  
    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.
    r   )rË   rO   ÚceilingÚNerX   rĚ   c             S   s   dd | D S )Nc             S   s   g | ]}d | qS )r;   r-   )r*   r9   r-   r-   r.   r   ë  s    z4_check_antecedents_1.<locals>.tr.<locals>.<listcomp>r-   )rť   r-   r-   r.   rź   ę  s    z _check_antecedents_1.<locals>.trr;   rc   c              W   s   t |   d S )N)Ú_debug)Úmsgr-   r-   r.   r%   ˙  s    z#_check_antecedents_1.<locals>.debugz$Checking antecedents for 1 function:z*  delta=%s, eta=%s, m=%s, n=%s, p=%s, q=%sz  ap = %s, %sz  bq = %s, %sz"  cond_3=%s, cond_3*=%s, cond_4=%sz	  case 1:z	  case 2:z	  case 3:z  extra case:z  second extra case:)r   rË   rO   rč   ré   rX   rĚ   r´   r   rˇ   r   rą   rB   r@   rA   rC   Ú_check_antecedents_1r"   rś   rľ   r   rf   r   r   r   r   Úzipr   r   )&rŹ   r9   ÚhelperrË   rO   rč   ré   rX   rD   r´   Úetarć   r   r6   rm   rn   Zxirź   Útmpri   rK   Zcond_3Zcond_3_starZcond_4r%   ÚcondsZcase1Ztmp1Ztmp2Ztmp3rŃ   Zextrarj   Zcase2Zcase3Z
case_extrarä   Zcase_extra_2r-   r-   r.   rě   ×  s     0$8*

*
4
,

 

rě   c       
      C   sŔ   ddl m}m}m} t| j|\}}d| }x| jD ]}|||d 9 }q4W x"| jD ]}	||d|	 d 9 }qTW x"| jD ]}||d| d  }qxW x| j	D ]}	|||	d  }qW |||S )ac  
    Evaluate int_0^\infty g dx using G functions,
    assuming the necessary conditions are fulfilled.

    >>> 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   )rW   Ú	gammasimprM   r;   )
r   rW   rň   rM   r   rˇ   rB   r@   rś   rľ   )
rŹ   r9   rW   rň   rM   rď   rć   r4   ri   rK   r-   r-   r.   Ú	_int0oo_1L  s    ró   c                s´  ddl m} fdd}t|\}}	t|j\}}
t|j\}}|
dk dkrb|
 }
t|}|dk dkr|| }t|}|
jr|jsdS |
j|
j }}|j|j }}||| || }|||  }|||  }t||\}}t||\}}||}||}| || 9 } t|j\}}t|j\}}|	d | d  | t	||    }  fdd	}t
||j||j||j||j| }t
|j|j|j|j| }t| dd
||fS )a  
    Rewrite the integral fac*po*g1*g2 from 0 to oo in terms of G functions
    with argument c*x.
    Return C, f1, f2 such that integral C f1 f2 from 0 to infinity equals
    integral fac po g1 g2 from 0 to infinity.

    >>> 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)
    r   )Úilcmc          	      s@   t | j\}}|  Ą }t| j| j| j| jt|| |  S )N)	r   rˇ   rĺ   r"   r@   rľ   rB   rś   ră   )rŹ   rK   ri   Zper)râ   r9   r-   r.   Úpb}  s    z_rewrite_saxena.<locals>.pbTNr;   c                s    fdd| D S )Nc                s   g | ]}|  qS r-   r-   )r*   rK   )r   r-   r.   r   Ł  s    z/_rewrite_saxena.<locals>.tr.<locals>.<listcomp>r-   )rť   )r   r-   r.   rź   ˘  s    z_rewrite_saxena.<locals>.tr)Úpolar)Zsympy.core.numbersrô   r   rˇ   r˝   Úis_Rationalrm   rn   rş   r   r"   r@   rľ   rB   rś   r   )rE   rŤ   Úg1Úg2r9   râ   rô   rő   rć   rä   Úb1Úb2Zm1Zn1Zm2Zn2ÚtauÚr1Zr2ÚC1ÚC2Úa1ri   Úa2rź   r-   )r   râ   r9   r.   Ú_rewrite_saxenag  s>    ,r  c       3         s|  ddl m	m}m}m}m}m}mm}m	}	 ddl m
 m}
 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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	
d       d      dk}t|d	
d       d      dk}t|
|t k }|t|
|t }t|
|t k } |t|
|t }!|||  t | }"|	|"  }#|	|"  }$|#d|$ krţt||d|| dkt||#d	
   dk 	
   dk }%nž fdd}&t||d|d | dktt||#d|&|#t	
   dk ||#d}%t||d|d | dktt||$d|&|$t	
   dk ||$d}'t|%|'}%yŚ td    |  td    |  }(t|(dkdkr&|(dk})n<f	dd}*t|*dd|*dd t||
d||
df|*||
d|*||
d t||
d||
df|*d||
|*d||
 t||
d||
df|*||
||
df}+|(dkt||(d||+d	|dkt||(d||+d	|dkg},t|, })W n tk
r~   d})Y nX xz|df|df|df|df|df|df|df|df|d f|d!f|d"f| d#f|!d$f|%d%f|)d&fgD ]\}-}.td'|. |- qŕW g fd(d)}/t|| | | dk|jdk|jdk||||| g7 |/d t|||d|jdkjdk	
dk |||| 	g7 |/d t|||d|jdkjdk	dk ||||	g7 |/d t||||d||djdkjdk	dk 	
dk ||||g7 |/d t||||d||djdkjdk	
 dk ||||g7 |/d tk|jdk|jdk|dk||||||!
g7 |/d tk |jdk|jdk|dk||||||!
g7 |/d tk|jdk|jdk|dk|||||| 
g7 |/d tk |jdk|jdk|dk|||||| 
g7 |/d  tk|||d|dkjdk	
dk |||||!g7 |/d! tk |||d|dkjdk	
dk |||||!g7 |/d" t|k|dk||djdk	dk |||||g7 |/d# t|k |dk||dj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k k |dk|dk||||||||!|%g7 |/d+ t||d|jdk|jdk|jdk|||g7 |/d, t||d|jdk|jdk|jdk|||g7 |/d- t||d|jdk|jdk|jdk||| g7 |/d. t||d|jdk|jdk|jdk||| g7 |/d/ t||| d|jdk|jdk||||| g7 |/d0 t||| d|jdk|jdk||||| g7 |/d1 t|dd2}0t|dd2}1t|1||d|k |jdk||||g7 |/d3 t|1||d|k |jdk||||g7 |/d4 t|0||d|k |jdk| |||g7 |/d5 t|0||d|k |jdk| |||g7 |/d6 t }2t|2dkr|2S t|| k||d||d|jdk|jdk|jdkt|
||  d t k ||||%|)g7 |/d7 t|| k||d||d|jdk|jdk|jdkt|
||  d t k ||||%|)g7 |/d8 t|d ||d||d|jdk|jdk|dk|t t|
k ||||%|)g7 |/d9 t|d ||d||d|jdk|jdk|dk|t t|
k ||||%|)g7 |/d: td k ||d||d|jdk|jdk|dk|t t|
k t|
||  d t k ||||%|)g7 |/d; td k||d||d|jdk|jdk|dk|t t|
k t|
||  d t k ||||%|)g7 |/d< t||d||d|| dk|jdk|jdk|jdkt|
||  d t k ||| |%|)g7 |/d= t||d||d|| k|jdk|jdk|jdkt|
||  d t k ||| |%|)g7 |/d> t||d||d|d |jdk|jdk|dk|t t|
k t|
|d t k ||| |%|)g7 |/d? t||d||d|d |jdk|jdk|dk|t t|
k t|
|d t k ||| |%|)g7 |/d@ t||d||dd k |jdk|jdk|dk|t t|
k t|
||  d t k ||| |%|)g7 |/dA t||d||dd k|jdk|jdk|dk|t t|
k t|
||  d t k ||| |%|)g7 |/dB t S )Cz> Return a condition under which the integral theorem applies. r   )	rX   rË   ré   r    rw   r   r!   re   rM   )rD   rĚ   rc   r;   zChecking antecedents:z1  sigma=%s, s=%s, t=%s, u=%s, v=%s, b*=%s, rho=%sz1  omega=%s, m=%s, n=%s, p=%s, q=%s, c*=%s, mu=%s,z"  phi=%s, eta=%s, psi=%s, theta=%sc                 sN   xH gD ]<} x6| j D ],}x&| jD ]}|| }|jr"|jr"dS q"W qW q
W dS )NFT)r@   rB   Ú
is_integerÚis_positive)rŹ   r+   ÚjZdiff)rř   rů   r-   r.   Ú_c1Í  s    z_check_antecedents.<locals>._c1c                s,   g | ]$} j D ]}d | | dkqqS )r;   r   )rB   )r*   r+   r  )rů   rX   r-   r.   r   Ö  s    z&_check_antecedents.<locals>.<listcomp>c                s,   g | ]$} j D ]}d | | dk qqS )r;   rc   )r@   )r*   r+   r  )rů   rX   r-   r.   r   ×  s    c                s:   g | ]2} d | d     t d d kqS )r;   rp   rc   )r   )r*   r+   )Úmurm   rn   rX   r-   r.   r   Ř  s    c                s6   g | ].} d |    t d d kqS )r;   rp   rc   )r   )r*   r+   )r  rm   rn   rX   r-   r.   r   Ů  s    c                s:   g | ]2}  d | d     t d d kqS )r;   rp   rc   )r   )r*   r+   )rX   ÚrhoÚur¸   r-   r.   r   Ú  s    c                s6   g | ].}  d |    t d d kqS )r;   rp   rc   )r   )r*   r+   )rX   r  r	  r¸   r-   r.   r   Ű  s    c                s   | dkot  d|  tk S )aś  Returns True if abs(arg(1-z)) < pi, avoiding arg(0).

            Note: 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)`
            r;   )r   r   )r'   )rŇ   r-   r.   Ú_condř  s    
z!_check_antecedents.<locals>._condFc                sP   |   t  d     |  t d      S )Nr;   )r   )Úc1Úc2)	Úomegarm   Úpsirn   Úsigmar!   Úthetar	  r¸   r-   r.   Ú	lambda_s0$  s    &z%_check_antecedents.<locals>.lambda_s0rl   Trp   ro   é   é   é   é   é	   é
   é   é   é   é   é   z  c%s:c                s   t d|   d  d S )Nz
  case %s:rl   )rę   )Úcount)rń   r-   r.   Úpr=  s    z_check_antecedents.<locals>.prr   é   é   é   é   é   é   é   )rî   ZE1ZE2ZE3ZE4é   é   é   é   é   é   é   é   é    é!   é"   é#   ) r   rX   rË   ré   r    rw   r   r!   re   rM   rD   rĚ   r   rˇ   r   rą   rB   r@   rA   rC   rf   r   r   rę   r   r   rß   r   Ú	TypeErrorr  Zis_negativerě   )3rř   rů   r9   rË   ré   r    rw   r   re   rM   rD   rć   rä   rj   r   r6   ZbstarZcstarÚphirď   r  r  r  Zc3Zc4Zc5Zc6Zc7Zc8Zc9Zc10Zc11Zc12Zc13Zz0ZzosZzsoZc14r
  Zc14_altZlambda_cZc15r  Zlambda_srđ   rF   r+   r  Z
mt1_existsZ
mt2_existsrd   r-   )rŇ   rń   rř   rů   r  r  rm   r  rn   rX   r  r  r!   r  r	  r¸   r.   Ú_check_antecedentsŞ  sŽ   ,00$$** ((	

"&"" "
&$.
..$$$    ((((2222  ,,,,6600.0660000r4  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.

    >>> from sympy.integrals.meijerint import _int0oo
    >>> from sympy.abc import s, t, m
    >>> from sympy import meijerg, S
    >>> g1 = meijerg([], [], [-S(1)/2, 0], [], s**2*t/4)
    >>> g2 = meijerg([], [], [m/2], [-m/2], t/4)
    >>> _int0oo(g1, g2, t)
    4*meijerg(((1/2, 0), ()), ((m/2,), (-m/2,)), s**(-2))/s**2
    c             S   s   dd | D S )Nc             S   s   g | ]
}| qS r-   r-   )r*   r9   r-   r-   r.   r   ě  s    z(_int0oo.<locals>.neg.<locals>.<listcomp>r-   )rť   r-   r-   r.   Únegë  s    z_int0oo.<locals>.neg)r   rˇ   rB   r   r@   rľ   rś   r"   )rř   rů   r9   rď   rć   r  r5  r   r  rú   rű   r-   r-   r.   Ú_int0ooÚ  s    r6  c                sn   t ||\}t |j|\}  fdd}t| |    ddt||j||j||j||j|jfS )z Absorb ``po`` == x**s into g. c                s    fdd| D S )Nc                s   g | ]}|   qS r-   r-   )r*   rj   )ri   rä   r-   r.   r   ú  s    z2_rewrite_inversion.<locals>.tr.<locals>.<listcomp>r-   )rť   )ri   rä   r-   r.   rź   ů  s    z_rewrite_inversion.<locals>.trT)rö   )r   rˇ   r   r"   r@   rľ   rB   rś   )rE   rŤ   rŹ   r9   rć   rK   rź   r-   )ri   rä   r.   Ú_rewrite_inversionô  s
    r7  c                sŚ  ddl mmmm mmmm}m	}m
 td jt\}}|dk rjt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d
d	 }n	d
krd
}n|}d
	 d	 |j  |j  	 j}td||||	|
||	f  td||f  j|d	 ks¤|d
kr||	ks¤td dS xDjD ]:}x2jD ](}|| jr¸||kr¸td dS q¸W qŹW ||	krtd  
fddjD  S  
fdd}	
fdd}	fdd}	fdd}g }| d
|k||	k d
|k|t | td	 k|dk|t |d
   g7 }| |d
 |k|d
 |	k|dk|td	 k |dk|| d
 t | td	 k|t |	|   | t |	|   g7 }| ||	k ||	k|dk|dk	| t | td	 k|g7 }|  ||	d	 kd
|
k|
	d	 k |d
 || k|| ||	 d	 k|dk|td	 k |
d
 t | td	 k|t |  | t |  g7 }| ||	k d
|k|dk|dk||t  td	 k |
| t | td	 k|t |  | t |  g7 }||dkg7 }| S )z7 Check antecedents for the laplace inversion integral. r   )
rX   Úimr   r   rË   r   rw   r   Únanré   z#Checking antecedents for inversion:z  Flipping G.c                s  t |\}}| |9 } ||| 9 }||9 }g }|| t d  }| | t d  }	|rr|}
n|	}
| |d|dk| dkg7 }| |d|d|dk|
dk g7 }| |d|d|dk|
dk| dkg7 }| S )Nrc   r   rl   )r   r   )rK   ri   r   r'   ZplusÚcoeffZexponentrń   ZwpZwmÚw)	r   rË   rw   ré   r   r   r8  rX   r9   r-   r.   Ústatement_half
  s    ,4,z4_check_antecedents_inversion.<locals>.statement_halfc                s"    | |||d| |||dS )zW Provide a convergence statement for z**a * exp(b*z**c),
             c/f sphinx docs. TFr-   )rK   ri   r   r'   )r   r<  r-   r.   Ú	statement  s    z/_check_antecedents_inversion.<locals>.statementrc   r;   z9  m=%s, n=%s, p=%s, q=%s, tau=%s, nu=%s, rho=%s, sigma=%sz   epsilon=%s, theta=%s, delta=%sz-  Computation not valid for these parameters.Fz  Not a valid G function.z$  Using asymptotic Slater expansion.c                s   g | ]} |d  ddqS )r;   r   r-   )r*   rK   )r=  r'   r-   r.   r   K  s    z0_check_antecedents_inversion.<locals>.<listcomp>c                s    fddj D  S )Nc                s   g | ]} |d  ddqS )r;   r   r-   )r*   rK   )r=  r'   r-   r.   r   N  s    z;_check_antecedents_inversion.<locals>.E.<locals>.<listcomp>)r@   )r'   )r   rŹ   r=  )r'   r.   ÚEM  s    z'_check_antecedents_inversion.<locals>.Ec                s     d  | S )Nr;   r-   )r'   )r  r=  r  r-   r.   ÚHP  s    z'_check_antecedents_inversion.<locals>.Hc                s     d  | dS )Nr;   Tr-   )r'   )r  r<  r  r-   r.   ÚHpS  s    z(_check_antecedents_inversion.<locals>.Hpc                s     d  | dS )Nr;   Fr-   )r'   )r  r<  r  r-   r.   ÚHmV  s    z(_check_antecedents_inversion.<locals>.Hm)r   rX   r8  r   r   rË   r   rw   r   r9  ré   rę   rˇ   r   Ú_check_antecedents_inversionr˝   r   rą   rB   r@   rA   rC   r´   r  r   )rŹ   r9   r   r9  rć   rĄ   r   r6   rm   rn   rü   rf   r  Úepsilonr´   rK   ri   r>  r?  r@  rA  rń   r-   )r   rË   rw   ré   r   r   rŹ   r8  rX   r  r=  r<  r  r9   r'   r.   rB  ˙  sp    00

$$	
.".>$$&&6.6rB  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ž   r"   r@   rľ   rB   rś   )rŹ   r9   rj   ri   rK   rš   r-   r-   r.   Ú_int_inversionx  s    ,rD  NTc       &         s  ddl m}m}mm}m} ts,i att t| t	rÂddl m
} || j| |Ą\}}	t|	dkrhdS |	d }	|	jr|	j|ks|	jjsdS n|	|krdS ddt	| j| j| j| j||	 fgdfS | }
|  |tĄ} t| t}|tkr~t| }x|D ]\}}}}| j|dd}|röi }x.| Ą D ]"\}}|||dddd	||< q$W |}t|tsd| |Ą}|d
krpqöt|ttfs|| |Ą}t|d
krqöt|ts˛||}g }xś|D ]Ž\}}t|| |Ą t|Ądd	|}y| |Ą t|Ą}W n t k
r   wźY nX |||f   !| Ąr6qźt	|j|j|j|j||jdd	}| "||f Ą qźW |rö||fS qöW |sdS t#d ddl$m%}m&m'}m(  ddl mm)}m}m*m+  fdd}|
} t,dd| }fdd}y,|| |||d
dd\}} }!||||| }W n |k
r8   d}Y nX |dkrÂt-dd}"|"| j.krÂt/| |rÂy@||  ||"| Ą|||dd
d\}} }!|||||  |"dĄ}W n |k
rŔ   d}Y nX |dksÜ| !||Ąrčt#d dS t0 1|Ą}#g }x|#D ]~} |  |Ą\}$}	t|	dkr$t2d|	d }t|j|\}"}%||$dt	|j|j|j|j|||"dddd	||%  fg7 }qüW t#d| |dfS )aH  
    Try to rewrite f as a sum of single G functions of the form
    C*x**s*G(a*x**b), where b is a rational number and C is independent of x.
    We guarantee that result.argument.as_coeff_mul(x) returns (a, (x**b,))
    or (a, ()).
    Returns a list of tuples (C, s, G) and a condition cond.
    Returns None on failure.
    r   )rŠ   rM   r   ÚzooÚTuple)Úfactorr;   NT)Úold)Zlift)Zexponents_onlyFz)Trying recursive Mellin transform method.)Úmellin_transformÚinverse_mellin_transformÚIntegralTransformErrorÚMellinTransformStripError)r   r9  rE  ÚsimplifyÚcancelc                sJ   y| |||dddS   k
rD   t | |||dddS X dS )zÔ Calling simplify() all the time is slow and not helpful, since
            most of the time it only factors things in a way that has to be
            un-done anyway. But sometimes it can remove apparent poles. T)Z
as_meijergÚneedevalN)r	   )ÚFrä   r9   Ústrip)rL  rN  rJ  rM  r-   r.   Úmy_imtŮ  s    

z_rewrite_single.<locals>.my_imträ   zrewrite-singlec                sl   ddl m}m} t| |dd}|d k	r\|\}}t||dd}t||f|| |d fdfS || |d fS )Nr   )ÚIntegralr   T)Úonly_doubleZnonrepsmall)Zrewrite)r   rS  r   Ú_meijerint_definite_4Ú_my_unpolarifyr   )r,   r9   rS  r   rd   r4   rF   )r   r-   r.   Úmy_integratoré  s    z&_rewrite_single.<locals>.my_integrator)Ú
integratorrM  rO  rK   )rX  rO  rM  z"Recursive Mellin transform failed.zUnexpected form...z"Recursive Mellin transform worked:)3r   rŠ   rM   r   rE  rF  Ú_lookup_tabler   r¤   r"   rG  rˇ   r   rą   r   r   r   r÷   r@   rľ   rB   rś   rq   r'   r=   rĽ   ÚitemsrŢ   r   rß   r   r   Ú
ValueErrorr3   r>   rę   Zsympy.integrals.transformsrI  rJ  rK  rL  r9  rM  rN  rĹ   rŔ   r   rÉ   r   rŞ   ÚNotImplementedError)&r,   r9   Ú	recursiverŠ   rM   rE  rF  rG  r:  r   Úf_rj   rť   r?   ZtermsrF   rG   rq   Zsubs_rÚ   rŰ   r4   rE   rŹ   rý   rI  rK  r9  rR  rä   rW  rP  rQ  rć   rK   r2   r   ri   r-   )rL  rN  rJ  r   rM  r.   Ú_rewrite_single  sŔ    
(




	







r_  c             C   s8   t | |\}}}t|||}|r4|||d |d fS dS )zö
    Try to rewrite f using a (sum of) single G functions with argument a*x**b.
    Return fac, po, g such that f = fac*po*g, fac is independent of x
    and po = x**s.
    Here g is a result from _rewrite_single.
    Return None on failure.
    r   r;   N)r­   r_  )r,   r9   r]  rE   rŤ   rŹ   r-   r-   r.   Ú	_rewrite1  s    r`  c                sŢ   t |  \}}}t fddt|D r.dS t|}|s>dS tt| fdd fdd fddg}xndD ]f}x`|D ]X\}}t| |}	t| |}
|	rz|
rzt|	d	 |
d	 }|d
krz|||	d |
d |fS qzW qpW dS )a  
    Try to rewrite f as a product of two G functions of arguments a*x**b.
    Return fac, po, g1, g2 such that f = fac*po*g1*g2, where fac is
    independent of x and po is x**s.
    Here g1 and g2 are results of _rewrite_single.
    Returns None on failure.
    c             3   s   | ]}t | d dkV  qdS )FN)r_  )r*   r   )r9   r-   r.   r/   /  s    z_rewrite2.<locals>.<genexpr>Nc                s&   t tt| d  tt| d  S )Nr   r;   )Úmaxrą   r   )rm   )r9   r-   r.   r:   5  s    z_rewrite2.<locals>.<lambda>c                s&   t tt| d  tt| d  S )Nr   r;   )ra  rą   rŁ   )rm   )r9   r-   r.   r:   6  s    c                s&   t tt| d  tt| d  S )Nr   r;   )ra  rą   r¨   )rm   )r9   r-   r.   r:   7  s   )FTr;   Fr   )r­   rČ   rŻ   r˛   r   r$   r_  r   )r,   r9   rE   rŤ   rŹ   rť   r]  Zfac1Zfac2rř   rů   rF   r-   )r9   r.   Ú	_rewrite2&  s$    


rb  c             C   sä   ddl m}m} g }xltt| |tdhB tdD ]L}t|  ||| Ą|}|sRq2| ||| Ą}t	|||rz| 
|Ą q2|S q2W |  tĄrĐtd tt| |}|rĐt|tk	rĆtt|| tĄS | |Ą |rŕtt|S dS )a#  
    Compute an indefinite integral of ``f`` by rewriting it as a G function.

    Examples
    ========

    >>> from sympy.integrals.meijerint import meijerint_indefinite
    >>> from sympy import sin
    >>> from sympy.abc import x
    >>> meijerint_indefinite(sin(x), x)
    -cos(x)
    r   )Úhyperr"   )Úkeyz*Try rewriting hyperbolics in terms of exp.N)r   rc  r"   Úsortedr¨   r   r&   Ú_meijerint_indefinite_1rq   r)   r>   r3   r   rę   Úmeijerint_indefiniter   r   r   r   r   r˘   r   ÚextendÚnextr$   )r,   r9   rc  r"   ÚresultsrK   r4   Úrvr-   r-   r.   rg  D  s(    "

rg  c                s@  ddl m}m}m}m} td| d t| }|dkr<dS |\}}}	}
td| td}x`|	D ]V\}}}t|j	\}}t|\}}||7 }|| ||d| |    }|d | d  t
dd	td} fd
d}tdd ||jD r.t||j||jdg ||jdg ||j| }n4t||jdg ||j||j||jdg |}d}|dk s|  dĄ ||Ąrd}t| |||  Ą|d}|t|| dd7 }qbW fdd}||}|jrg }x.|jD ]$\}}
t||}|||
fg7 }qćW t| }nt||}t|t|
f|| dfS )z0 Helper that does not attempt any substitution. r   )rS  r   r9  rE  z,Trying to compute the indefinite integral ofZwrtNz could rewrite:r;   rj   zmeijerint-indefinitec                s    fdd| D S )Nc                s   g | ]}|  d  qS )r;   r-   )r*   rK   )r  r-   r.   r     s    z7_meijerint_indefinite_1.<locals>.tr.<locals>.<listcomp>r-   )rm   )r  r-   r.   rź     s    z#_meijerint_indefinite_1.<locals>.trc             s   s    | ]}|j o|d kdkV  qdS )r   TN)r  )r*   ri   r-   r-   r.   r/     s    z*_meijerint_indefinite_1.<locals>.<genexpr>)ÚplaceT)rö   c                s0   ddl m} t|| dd} t |   Ąd ĄS )a  This multiplies out superfluous powers of x we created, and chops off
        constants:

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

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


        >>> 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
        r   )rN  F)Zdeepr;   )r   rN  r
   r   Z
_from_argsZas_coeff_add)r4   rN  )r9   r-   r.   Ú_clean  s    z'_meijerint_indefinite_1.<locals>._clean)r   rS  r   r9  rE  rę   r`  r   r   rˇ   rĹ   rČ   rB   r"   r@   rľ   rś   rq   r3   r   r   r(   r2   rV  r   )r,   r9   rS  r   r9  rE  rŽ   rE   rŤ   ZglrF   r4   rš   rä   rŹ   rK   ri   rć   r   Zfac_rj   rź   rd   rl  rm  rÝ   r   r-   )r  r9   r.   rf  i  sH    


62 
rf  c             C   s  ddl m}m}m}m}m}m}	 td| d|||f  |  |ĄrLtd dS |  |	Ąrbtd dS | |||f\}
}}}t	d}|  
||Ą} |}||kr tjd	fS g }|t krŇ|tkrŇt|  
|| Ą|| | S |t krŘtd
 t| |}td| xŘt|td	dtdg D ]ź}td| |js6td qt|  
||| Ą|}|dkrbtd qt|  
||| Ą|}|dkrtd q|\}}|\}}t|||}|dkrÂtd q|| }||fS W nŚ|tkrt| ||t}|d  |d fS ||fdtfkrHt| |}|r~t|d tr@| |Ą n|S n6|tkrŇx~t| |D ]p}|| dkd	kr^td|  t|  
||| Ąt|| |  |}|r^t|d trČ| |Ą n|S q^W |  
||| Ą} || }d}|tkr8|||| }t|}|  
||| Ą} | t|| | 9 } t}td|| td|  t| |}|r~t|d trz| |Ą n|S |
 tĄrđtd tt|
|||}|rđt|tk	rćtt|d |d   |Ą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.
    r   )rD   r   rw   r   r   ÚSingularityFunctionÚIntegratingzwrt %s from %s to %s.z+Integrand has DiracDelta terms - giving up.Nz5Integrand has Singularity Function terms - giving up.r9   Tz  Integrating -oo to +oo.z  Sensible splitting points:)rd  Ú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;   zTrying x -> x + %szChanged limits tozChanged function toz*Try rewriting hyperbolics in terms of exp.)$r   rD   r   rw   r   r   rn  rę   r3   r   rq   r   ÚZeror   Úmeijerint_definiter¨   re  r&   Zis_realÚ_meijerint_definite_2r×   r)   r"   r>   r   r   r   r   r   r   r   r   r˘   rh  ri  r$   )r,   r9   rK   ri   rD   r   rw   r   r   rn  r^  Zx_Za_Zb_rÄ   rj  r§   r   Zres1Zres2Zcond1Zcond2rF   r4   Úsplitr3  rk  r-   r-   r.   rr  Á  s°     















*
rr  c       	      C   sô   ddl m} ddlm} | dfg}|d d }|h}t|}||kr\||dfg7 }| |Ą t|}||kr||dfg7 }| |Ą | |tĄrźt||}||krź||dfg7 }| |Ą | t	t
Ąrđt|}||krđ||d	fg7 }| |Ą |S )
z6 Try to guess sensible rewritings for integrand f(x). r   )Úexpand_trig)ÚTrigonometricFunctionzoriginal integrandrl   r
   r	   zexpand_trig, expand_mulztrig power reduction)r   ru  Ú(sympy.functions.elementary.trigonometricrv  r
   rI   r	   r3   r   r    r!   r   )	r,   r9   ru  rv  r4   rÔ   ZsawZexpandedZreducedr-   r-   r.   Ú_guess_expansionL  s0    




rx  c             C   sl   t dd| dd}|  ||Ą} |}| dkr4tddfS x2t| |D ]$\}}td| t||}|r@|S q@W dS )a  
    Try to integrate f dx from zero to infinty.

    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.
    r9   zmeijerint-definite2T)Zpositiver   ZTryingN)rĹ   rq   r   rx  rę   Ú_meijerint_definite_3)r,   r9   ZdummyrŹ   Zexplanationr4   r-   r-   r.   rs  m  s    

rs  c                s   t |  }|r|d dkr|S | jrtd  fdd| jD }tdd |D rg }td}x"|D ]\}}||7 }||g7 }qdW t| }|dkr||fS d	S )
z˛
    Try to integrate f dx from zero to infinity.

    This function calls _meijerint_definite_4 to try to compute the
    integral. If this fails, it tries using linearity.
    r;   Fz#Expanding and evaluating all terms.c                s   g | ]}t | qS r-   )rU  )r*   rŹ   )r9   r-   r.   r     s    z)_meijerint_definite_3.<locals>.<listcomp>c             s   s   | ]}|d k	V  qd S )Nr-   )r*   rd   r-   r-   r.   r/     s    z(_meijerint_definite_3.<locals>.<genexpr>r   N)rU  Zis_Addrę   r2   r1   r   r   )r,   r9   r4   Zressrń   rd   r   r-   )r9   r.   ry    s    
ry  c             C   s   ddl m} t|| S )Nr   )rM   )r   rM   rß   )r,   rM   r-   r-   r.   rV  Ł  s    rV  c          
   C   s2  t d|  |sât| |dd}|dk	râ|\}}}}t d||| td}xf|D ]^\}	}
} |	dkr`qLt||	 |||
  | |\}	} ||	t| | 7 }t|t| |}|dkrLP qLW t|}|dkrČt d nt d| tt||fS t	| |}|dk	r.x4d	D ]*}|\}}}}}t d
|||| td}xś|D ]Ž\}}}x|D ]\}}}t
|| | ||||   ||||}|dkrt d dS |\}	}}t d|	|| t|t|||}|dkrźP ||	t||| 7 }q@W q0P q0W t|}|dkrt d|  qţt d| |r||fS tt||fS qţW dS )a`  
    Try to integrate f dx from zero to infinity.

    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.
    ro  F)r]  Nz#Could rewrite as single G function:r   zBut cond is always False.z&Result before branch substitutions is:)FTz!Could rewrite as two G functions:zNon-rational exponents.zSaxena subst for yielded:z&But cond is always False (full_pb=%s).)rę   r`  r   rç   ró   r   rě   rV  r   rb  r  r4  r6  )r,   r9   rT  rŽ   rE   rŤ   rŹ   rF   r4   rš   rä   râ   rř   rů   rţ   Ús1Úf1r˙   Ús2Úf2rd   Zf1_Zf2_r-   r-   r.   rU  ¨  s`    









rU  c              C   s¤  ddl m}m}m}m}m}m}m}	m}
 | }|}t	ddd}|  
||Ą} td|  t| |shtd dS tj}| jrt| j}nt| |r| g}nd}|rÜg }g }x$|rĘ| Ą }t||r2||}|jrÜ||j7 }q¨yt|jd |\}}W n tk
r   d}Y nX |d	kr&| |Ą n
| |Ą q¨|jrž||}|jrV||j7 }q¨||jjkr˛yt|j|\}}W n tk
r   d}Y nX |d	kr˛| |||j Ą | |Ą q¨| |Ą q¨W || }|	| } || jkrXtd
| | ddl m}m} |||d}|dkr(td dS | t||  }td|| t| 
||Ą|fS t| |}|dk	r |\}}}}td||| td}xb|D ]Z\}}} t|| |||  | |\}} ||t | || 7 }t!|t"| |}|dkrP qW t#|}|dkrtd ntd| t#t$|}| %|
Ąs<||
|9 }| 
||| Ą}t|t&sh| 
||| Ą}ddl m'} t| 
||Ą|f|| 
||Ą||ddfS dS )aç  
    Compute the inverse laplace transform
    :math:\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   )rw   rS  r   r	   r^   r   r   r   rj   T)rö   zLaplace-invertingzBut expression is not analytic.Nr;   z.Expression consists of constant and exp shift:)rË   r8  Fz3but shift is nonreal, cannot be a Laplace transformz1Result is a delta function, possibly conditional:z#Could rewrite as single G function:zBut cond is always False.z"Result before branch substitution:)ÚInverseLaplaceTransform)(r   rw   rS  r   r	   r^   r   r   r   r   rq   rę   rÉ   r   rq  Zis_Mulr   r2   r¤   Úpopr   r   r>   r   r   r   rË   r8  r   r   r`  r7  rD  r   rB  rV  r   r3   rŢ   r~  ) r,   r9   rj   rw   rS  r   r	   r^   r   r   r   r^  Zt_Úshiftr2   rÝ   ZexponentialsrD   rÜ   rK   ri   rË   r8  rF   r4   rŽ   rE   rŤ   rŹ   rš   rä   r~  r-   r-   r.   Úmeijerint_inversioně  s¤    (
















r  )F)F)F)T)T)F)lr   Z
__future__r   r   Z
sympy.corer   r   r   r   Zsympy.core.exprtoolsr   Zsympy.core.functionr	   r
   r   Zsympy.core.addr   Zsympy.core.mulr   Zsympy.core.compatibilityr   Zsympy.core.cacher   Zsympy.core.symbolr   r   Zsympy.simplifyr   r   r   Zsympy.simplify.fur   rÖ   r   r   r   Z'sympy.functions.special.delta_functionsr   r   Z&sympy.functions.elementary.exponentialr   Z$sympy.functions.elementary.piecewiser   r   Z%sympy.functions.elementary.hyperbolicr   r   rw  r    r!   Zsympy.functions.special.hyperr"   Zsympy.utilities.iterablesr#   r$   Zsympy.utilities.miscr%   rę   Zsympy.utilitiesr&   r'   r)   r   Zsympy.utilities.timeutilsr   Ztimeitr=   r[  r   r   r   rŁ   r¨   r­   rŻ   r˛   rş   r˝   rž   rĆ   rĹ   rŔ   rÉ   r×   rß   ră   rç   rě   ró   r  r4  r6  r7  rB  rD  rY  r_  r`  rb  rg  rf  rr  rx  rs  ry  rV  rU  r  r-   r-   r-   r.   Ú<module>   s   	 [!%	e

u
C  2y 
%X !C