o
    ą8Vac2 ć                   @   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 ZVdodEdFZWdGdH ZXdodIdJZYdKdL ZZdMdN Z[dOdP Z\dQdR Z]dSdT Z^dUa_eeAdpdWdXZ`dpdYdZZad[d\ Zbd]d^ Zcd_d` ZdeAdadb Zedcdd Zfdedf Zgdgdh Zhdidj ZieAdodkdlZjdmdn ZkdUS )qaæ  
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
é    )ŚDictŚTuple)ŚooŚSŚpiŚExpr)Śfactor_terms)ŚexpandŚ
expand_mulŚexpand_power_base)ŚAdd©ŚMul©ŚRational)Ś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 |g ¢R  V  qd S ©N)Ś_has©Ś.0Śi©Śf© ś;/usr/lib/python3/dist-packages/sympy/integrals/meijerint.pyŚ	<genexpr>>   ó    z_has.<locals>.<genexpr>)r    ŚgetattrŚallŚargsŚhas)Śresr3   r4   r2   r5   r.   9   s   
r.   c           &         sņ	  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< 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jd |tjd  
fdd}|dd |dd |tjd |tjd |
|d g g dgg  |g dgtjgddgd d 	tdd  |g tjgdgtjtjgd d 	tdd  |g g tjgdgd d 	 |	g g dgtj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jtddgg dgdg fg d ||t ||t	tddgtjgdgdtjg fg d dd&lm }m!}m"}m#}m$}m%}m&}m'}m(} |||| 	 tj)tg dgddgg |d fg d |dgg tjgddgd d 	d  |g dgddgtjgd d 	 d  |tjgg dgtddtddg|dd  d 	 d  |g tjdgddgtjtjgd d 	td'  d  |g gd dgg  |dgg tjgdgd d	  |g dgdtjgg d d	  |tj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j |dgg tddgdtddg	d d  d( tj 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j 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ddd  d+S )-z8 Add formulae for the function -> meijerg lookup table. c                 S   s   t | tgdS )N©Zexclude)r   r+   )Śnr4   r4   r5   ŚwildD   ó   z"_create_lookup_table.<locals>.wildZpqabcr>   c                 S   s   | j o| dkS ©Nr   ©Ś
is_Integer©Śxr4   r4   r5   Ś<lambda>G   s    z&_create_lookup_table.<locals>.<lambda>)Z
propertiesTc	           	   
      s6      t| tg ” | |t|||||fg||f” d S r-   )Ś
setdefaultŚ_mytyper+   Śappendr&   )	ŚformulaŚanŚapŚbmŚbqŚargŚfacŚcondŚhint©Śtabler4   r5   ŚaddJ   s   
’z!_create_lookup_table.<locals>.addc                    s$      t| tg ” | |||f” d S r-   )rG   rH   r+   rI   )rJ   ŚinstrQ   rR   rS   r4   r5   ŚaddiN   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 ©Né   r   )r&   r+   )Śar4   r4   r5   ŚconstantR   s   ’z&_create_lookup_table.<locals>.constantr4   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u r|dkS d S )NTr   rB   )ŚclsrO   ©r\   r4   r5   Śeval]   s   
’z7_create_lookup_table.<locals>.IsNonPositiveInteger.evalN)Ś__name__Ś
__module__Ś__qualname__Śclassmethodra   r4   r`   r4   r5   ŚIsNonPositiveInteger[   s    rf   )Śgammar   r#   r   Śrer$   ŚsincŚsqrtŚsinhŚcoshŚ	factorialŚlogŚerfŚerfcŚerfiŚ
polar_liftrY   )rR   é   c                    s(    t dd | | d dd|     S )Né’’’’rs   rY   r   )ŚrŚsignŚnu)r   r4   r5   ŚA1w   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 )Nrs   rY   r4   ©ru   Zsgn)rx   rZ   rU   Śbrj   Śtr4   r5   Śtmpaddz   s
   , *żz$_create_lookup_table.<locals>.tmpaddrt   c                    s¦   t    | t d     t    |   d|  | d  gd|  | d  gdtjgg t    d |    | |  d S )Nrs   rY   r   )r+   r   ŚHalfry   )rx   rZ   rU   rz   ŚpŚqrj   r4   r5   r|      s   D2(žé   é   c                    s>   |  }d|  | t g dg|d  dg|d  g fgS )Nrt   rY   r   r%   ©ŚsubsŚN©rm   r>   r{   r4   r5   Ś	make_log1”   s   "’z'_create_lookup_table.<locals>.make_log1c                    s6   |  } |t dg|d  g g dg|d  fgS rX   r%   r   r   r4   r5   Ś	make_log2¦   s   "’z'_create_lookup_table.<locals>.make_log2c                    s    | |  S r-   r4   ©r   )r   r   r4   r5   Ś	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)0ŚlistŚmapr   r+   r   ŚOneŚsympyr\   r]   r^   rg   r   r#   r   rh   r$   ri   rj   rk   rl   rm   rn   ro   rp   rq   rr   r   r   Śabsr}   r   r&   r   r   r   r   r   r   r   r   r   ZNegativeOner   r   r   r   r   r   )&rT   r?   ŚcrW   r[   r]   r^   rf   rg   r#   r   rh   r$   ri   rk   rl   rn   ro   rp   rq   rr   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r4   )rx   rZ   rU   rz   rm   r   r   r>   r~   r   r   rj   r{   rT   r\   r5   Ś_create_lookup_tableB   s¾   H	.’.’:’:’4
’<6’.’



48**2  .ž(’ž, 
’ż248’,
’’",,4>>.FD2(8r”   )Śtimethisr&   c                    s\    | j vrdS | jrt| fS  fdd| jD }g }|D ]}|t|7 }q| ”  t|S )z4 Create a hashable entity describing the type of f. r4   c                    ó   g | ]}t | qS r4   )rH   ©r0   rZ   rD   r4   r5   Ś
<listcomp>'  ó    z_mytype.<locals>.<listcomp>)Śfree_symbolsZis_FunctionŚtyper:   r   ŚsortŚtuple)r3   rE   Śtypesr<   r{   r4   rD   r5   rH      s   

rH   c                   @   s   e Zd ZdZdS )Ś_CoeffExpValueErrorzD
    Exception raised by _get_coeff_exp, for internal use only.
    N)rb   rc   rd   Ś__doc__r4   r4   r4   r5   r¬   /  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)r   r®   r   Śas_coeff_mulr   ŚZeroŚis_PowŚbaser¬   r   r   )ŚexprrE   r®   r    Śmr4   r4   r5   Ś_get_coeff_exp6  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 ©NrY   )Śupdater±   r²   r   r:   )r³   rE   r<   rO   ©Ś_exponents_r4   r5   r¹   k  s   
’z_exponents.<locals>._exponents_©Śset)r³   rE   r<   r4   rø   r5   Ś
_exponentsX  s   	r¼   c                    s$   ddl m}  fdd|  |”D S )zB Find the types of functions in expr, to estimate the complexity. r   )r]   c                    s   h | ]
} |j v r|jqS r4   )r§   Śfunc)r0   ŚerD   r4   r5   Ś	<setcomp>|  s    z_functions.<locals>.<setcomp>)r   r]   Śatoms)r³   rE   r]   r4   rD   r5   Ś
_functionsy  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 )r=   )r   ©r0   r>   rD   r4   r5   r„     s    z*_find_splitting_points.<locals>.<listcomp>Zpqc                    sp   t | tsd S |    ”}|r&| dkr&| |  |  ” d S | jr+d S | jD ]} || q.d S rA   )Ś
isinstancer   ŚmatchrU   Zis_Atomr:   )r³   r<   r“   rO   ©Ścompute_innermostr~   r   rE   r4   r5   rĘ     s   

’z1_find_splitting_points.<locals>.compute_innermostrŗ   )r³   rE   Ś	innermostr4   rÅ   r5   Ś_find_splitting_points  s
   
rČ   c                 C   sź   ddl m}m} tj}tj}tj}t| } t | ”}|D ]S}||kr'||9 }q||jvr1||9 }q|j	rk||j
jvrk|j |”\}	}
|
|fkrQt|j |”\}	}
|
|fkrk|||j
 9 }||||	|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))
    r   )Śpolarifyr\   Fr   )r   rÉ   r\   r   r   r   r   Ś	make_argsr§   r±   r   r²   rÆ   r
   )r3   rE   rÉ   r\   rP   ŚpoŚgr:   rZ   r    r{   r4   r4   r5   Ś
_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   rY   )r   rŹ   r±   r   rC   r²   rI   )r3   r:   ŚgsrĢ   r>   r²   r4   r4   r5   Ś	_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))]
    rs   Nc                 S   s    g | ]\}}t | t | fqS r4   r   )r0   rE   Śyr4   r4   r5   r„   ž  ó     z%_mul_as_two_parts.<locals>.<listcomp>)rĻ   ŚlenrŖ   r'   )r3   rĪ   r4   r4   r5   Ś_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   s2   g }| D ]}t |D ]}| || | ” q
q|S )z5 (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) )ŚrangerI   )Śparamsr>   r<   rZ   r1   r4   r4   r5   Śinflate  s   ’z_inflate_g.<locals>.inflaterY   rs   )r   rŅ   rL   rN   rw   r   Śdeltar&   rK   ŚaotherrM   ŚbotherŚargument)rĢ   r>   rÖ   ŚvŚCr4   r4   r5   Ś
_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 ©rY   r4   r¤   r4   r4   r5   r„     ó    z'_flip_g.<locals>.tr.<locals>.<listcomp>r4   ©Ślr4   r4   r5   Śtr  r@   z_flip_g.<locals>.trrY   )r&   rM   rŁ   rK   rŲ   rŚ   )rĢ   rä   r4   r4   r5   Ś_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   rs   rY   rt   c                    s   g | ]}|d    qS rą   r4   rĀ   ©r~   r4   r5   r„   4  ó    z"_inflate_fox_h.<locals>.<listcomp>)Ś_inflate_fox_hrå   r   r~   r   rŻ   rŚ   r   r   rŌ   r&   rK   rŲ   rM   r   rŁ   )rĢ   rZ   r   ŚDr+   Śbsr4   rę   r5   rč     s   

&$rč   c                 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Śdr4   r4   r5   Ś_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.
    )Ś_dummiesr   )rģ   rķ   rī   r4   r4   r5   rė   F  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 v V  qd S r-   )r§   ©r0   r³   rD   r4   r5   r6   U  s    z_is_analytic.<locals>.<genexpr>)r   r   rņ   ŚanyrĄ   )r3   rE   r   rņ   r4   rD   r5   Ś_is_analyticQ  s    rõ   c                    sŠ  ddl m}m}m}mm}m}m}m m	m
m ddlm} t| |s'| 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}
|rŌd	}|
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 rSqH||kr_|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qHqAtt|d
 kr·q’fddt| jD | ”g }| j| } d} qļ|sė fdd}|  d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, 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   r   rO   Śperiodic_argumentr   rr   )ŚBooleanFunctionTzp q r)r_   rs   éž’’’FrY   c                    s   g | ]}|   ”qS r4   r   ©r0   rE   )r“   r4   r5   r„     r¦   z_condsimp.<locals>.<listcomp>Nc                    s   g | ]
\}}| vr|qS r4   r4   )r0   ŚkŚarg_)Ś	otherlistr4   r5   r„   §  s    
’c                    s   | j dkr	| j}n| jdkr| j }n| S |   ”}|s*|  ”}|sGt|rE|jd jsE|jd u rE|jd dkS | S | dkS ©Nr   rY   )ZlhsZrhsrÄ   rĆ   r:   Zis_polar)Śorigr³   r“   )rO   r   r~   rś   rr   r   rų   r4   r5   Śrepl_eq®  s   

’z_condsimp.<locals>.repl_eqc                 S   s   | j o| jdkS )Nz==)Zis_RelationalZrel_op)r³   r4   r4   r5   rF   æ  s    z_condsimp.<locals>.<lambda>)r   rö   r   r÷   rų   rł   r   r   rO   rś   r   rr   Śsympy.logic.boolalgrū   rĆ   r½   r   r   Ś	_condsimpr:   r   r   r   Ś	enumerater§   rÄ   rŅ   r   Śreplace)rQ   rö   r   r÷   rł   r   r   rū   Zchangeru   ZrulesŚfroŚtor>   Zarg1ZnumZ	otherargsŚarg2rž   Zarg3Śnewargsr  r4   )	rO   r“   r   r   r~   rś   rr   r   rų   r5   r  X  s   4
(’0’’ž ’žņ.


’’
’’

’
Ū(žr  c                 C   s   t | tr| S t|  ” S )z Re-evaluate the conditions. )rĆ   Śboolr  Zdoit)rQ   r4   r4   r5   Ś
_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 r-   r4   )rE   rŠ   r4   r4   r5   rF   ×  s    z&_my_principal_branch.<locals>.<lambda>)r   r  r  )r³   ŚperiodŚfull_pbr  r<   r4   r4   r5   Ś_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.
    rY   c                    ó    fdd| D S )Nc                    s    g | ]}|d     d  qS rą   r4   r¤   ©rz   Śsr4   r5   r„   ė  rŃ   z1_rewrite_saxena_1.<locals>.tr.<locals>.<listcomp>r4   rā   r  r4   r5   rä   ź  ó   z_rewrite_saxena_1.<locals>.tr)
rµ   rŚ   Ś
get_periodr  r   r&   rK   rŲ   rM   rŁ   )	rP   rĖ   rĢ   rE   Ś_rZ   r  rÜ   rä   r4   r  r5   Ś_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rTdd }tt|| j|| j|| j|| j||
 |S g }| jD ]}||| dk g7 }qY| jD ]}|dd|| k g7 }qit| }| jD ]}||| dk g7 }q~| jD ]}|dd|| k g7 }q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}t||	d d D ]}||t||
|	d|  t g7 }q)|	dkt||
|	t k g}||
d|g}|rYg }|||fD ]}|t|| |  g7 }q^||7 }|d| |g}|r~g }t||d|d |k||kt||
|	t k g|¢R  g} || 7 }|d|  ||g}|r­g }t||k d|k|	dk|t||
|	t g|¢R  g}!|!t||d k||	d|t||
dg|¢R  g7 }!||!7 }|d|! g }"|"|||||	d|||
d||
dg7 }"|s|"|g7 }"g }#t| j| jD ]\}}|#|| g7 }#q|"|t|# dk g7 }"t|" }"||"g7 }|d|"g t|	dkt||
|	t k g}$|sT|$|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.
    r   )r÷   r^   ŚceilingŚNerh   rų   c                 S   rŽ   )Nc                 S   rß   rą   r4   rż   r4   r4   r5   r„     rį   z4_check_antecedents_1.<locals>.tr.<locals>.<listcomp>r4   rā   r4   r4   r5   rä     r@   z _check_antecedents_1.<locals>.trrY   rs   c                  W   s   t |   d S r-   ©Ś_debug)Śmsgr4   r4   r5   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÷   r^   r  r  rh   rų   r×   rµ   rŚ   r   rŅ   rM   rK   rL   rN   Ś_check_antecedents_1r&   rŁ   rŲ   r   rw   r   rŌ   r   r   Śzipr   r   )%rĢ   rE   Śhelperr÷   r^   r  r  rh   rO   r×   Śetar  r“   r>   r~   r   rä   Śtmprz   rZ   Zcond_3Zcond_3_starZcond_4r)   ŚcondsZcase1Ztmp1Ztmp2Ztmp3rž   Zextrar{   Zcase2Zcase3Z
case_extrar  Zcase_extra_2r4   r4   r5   r  š  s¦    0’ž



$’8(
’
’
*
’6
,

 

r  c           
      C   s°   ddl m}m}m} t| j|\}}d| }| jD ]
}|||d 9 }q| jD ]}	||d|	 d 9 }q'| jD ]}||d| d  }q7| j	D ]
}	|||	d  }qG|||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   )rg   Ś	gammasimpr\   rY   )
r   rg   r$  r\   rµ   rŚ   rM   rK   rŁ   rŲ   )
rĢ   rE   rg   r$  r\   r!  r  r<   rz   rZ   r4   r4   r5   Ś	_int0oo_1d  s   



r%  c                    s“  ddl m} fdd}t|\}}	t|j\}}
t|j\}}|
dk dkr1|
 }
t|}|dk dkr>| }t|}|
jrD|jsFd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``.

    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)
    r   )Śilcmc              	      s@   t | j\}}|  ” }t| j| j| j| jt|| |  S r-   )	rµ   rŚ   r  r&   rK   rŲ   rM   rŁ   r  )rĢ   rZ   rz   Zper)r  rE   r4   r5   Śpb  s
   ’z_rewrite_saxena.<locals>.pbTNrY   c                    ó    fdd| D S )Nc                    s   g | ]}|  qS r4   r4   r¤   r   r4   r5   r„   Å  rį   z/_rewrite_saxena.<locals>.tr.<locals>.<listcomp>r4   rā   r   r4   r5   rä   Ä  ó   z_rewrite_saxena.<locals>.tr©Zpolar)Śsympy.core.numbersr&  rµ   rŚ   rå   Śis_Rationalr~   r   rŻ   r   r&   rK   rŲ   rM   rŁ   r   )rP   rĖ   Śg1Śg2rE   r  r&  r'  r  r  Śb1Śb2Zm1Zn1Zm2Zn2ŚtauŚr1Zr2ŚC1ŚC2Śa1rz   Śa2rä   r4   )r   r  rE   r5   Ś_rewrite_saxena  s>   ,r7  c           3         st  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|%|'}%	 zŅ 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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'|. |- qmg fd(d)}/t|| | | dk|jdu |jdu ||||| g7 |/d t|||d|jdu jdu 	
dk |||| 	g7 |/d t|||d|jdu jdu 	dk ||||	g7 |/d t||||d||djdu jdu 	dk 	
dk ||||g7 |/d t||||d||d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 |jdu |jdu |dk|||||| 
g7 |/d  tk|||d|dkjdu 	
dk |||||!g7 |/d! tk |||d|dkjdu 	
dk |||||!g7 |/d" t|k|dk||djdu 	dk |||||g7 |/d# t|k |dk||djdu 	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u |jdu |jdu |||g7 |/d, t||d|jdu |jdu |jdu |||g7 |/d- t||d|jdu |jdu |jdu ||| g7 |/d. t||d|jdu |jdu |jdu ||| g7 |/d/ t||| d|jdu |jdu ||||| g7 |/d0 t||| d|jdu |jdu ||||| g7 |/d1 t|dd2}0t|dd2}1t|1||d|k |jdu ||||g7 |/d3 t|1||d|k |jdu ||||g7 |/d4 t|0||d|k |jdu | |||g7 |/d5 t|0||d|k |jdu | |||g7 |/d6 t }2t|2dkr|2S t|| k||d||d|jdu |jdu |jdu t|
||  d t k ||||%|)g7 |/d7 t|| k||d||d|jdu |jdu |jdu t|
||  d t k ||||%|)g7 |/d8 t|d ||d||d|jdu |jdu |dk|t t|
k ||||%|)g7 |/d9 t|d ||d||d|jdu |jdu |dk|t t|
k ||||%|)g7 |/d: td k ||d||d|jdu |jdu |dk|t t|
k t|
||  d t k ||||%|)g7 |/d; td k||d||d|jdu |jdu |dk|t t|
k t|
||  d t k ||||%|)g7 |/d< t||d||d|| dk|jdu |jdu |jdu t|
||  d t k ||| |%|)g7 |/d= t||d||d|| k|jdu |jdu |jdu t|
||  d t k ||| |%|)g7 |/d> t||d||d|d |jdu |jdu |dk|t t|
k t|
|d t k ||| |%|)g7 |/d? t||d||d|d |jdu |jdu |dk|t t|
k t|
|d t k ||| |%|)g7 |/d@ t||d||dd k |jdu |jdu |dk|t t|
k t|
||  d t k ||| |%|)g7 |/dA t||d||dd k|jdu |jdu |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   )	rh   r÷   r  r#   r   r   r$   rv   r\   )rO   rų   rs   rY   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 ]} | j D ]}| jD ]}|| }|jr|jr   dS qq	qdS )NFT)rK   rM   Ś
is_integerŚis_positive)rĢ   r1   ŚjZdiff)r-  r.  r4   r5   Ś_c1ļ  s   


ż’z_check_antecedents.<locals>._c1c                    s,   g | ]} j D ]}d | | dkqqS ©rY   r   )rM   ©r0   r1   r:  ©r.  rh   r4   r5   r„   ų  ó   , z&_check_antecedents.<locals>.<listcomp>c                    s,   g | ]} j D ]}d | | dk qqS )rY   rs   ©rK   r=  r>  r4   r5   r„   ł  r?  c                    s6   g | ]} d | d     t ddkqS ©rY   éż’’’rs   r   r/   ©Śmur~   r   rh   r4   r5   r„   ś  ó   6 c                    s2   g | ]} d |    t ddkqS rA  r   r/   rC  r4   r5   r„   ū  ó   2 c                    s6   g | ]}  d | d     t ddkqS rA  r   r/   ©rh   ŚrhoŚurŪ   r4   r5   r„   ü  rE  c                    s2   g | ]}  d |    t ddkqS rA  r   r/   rG  r4   r5   r„   ż  rF  c                    s   | dko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)`
            rY   )r   r   ©r+   )r’   r4   r5   Ś_cond  s   z!_check_antecedents.<locals>._condFc                    sP   |   t  d     |  t d      S r¶   )r   )Śc1Śc2)	Śomegar~   Śpsir   Śsigmar$   ŚthetarI  rŪ   r4   r5   Ś	lambda_s0I  s   &&’z%_check_antecedents.<locals>.lambda_s0rt   Tr   r   é   é   é   é   é	   é
   é   é   é   é   é   z  c%s:c                    s   t d|   d  d S )Nz
  case %s:rt   r  )Ścount)r#  r4   r5   Śprb  ó   z_check_antecedents.<locals>.prr   é   é   é   é   é   é   é   )r   ZE1ZE2ZE3ZE4é   é   é   é   é   é   é   é   é    é!   é"   é#   ) r   rh   r÷   r  r#   r   r   r$   rv   r\   rO   rų   rµ   rŚ   r   rŅ   rM   rK   rL   rN   rw   r   r   r  r   r   r  r   Ś	TypeErrorr9  Zis_negativer  )3r-  r.  rE   r÷   r  r#   r   r   rv   r\   rO   r  r  r{   r“   r>   ZbstarZcstarŚphir!  r;  rL  rM  Zc3Zc4Zc5Zc6Zc7Zc8Zc9Zc10Zc11Zc12Zc13Zz0ZzosZzsoZc14rK  Zc14_altZlambda_cZc15rR  Zlambda_sr"  rQ   r1   r_  Z
mt1_existsZ
mt2_existsru   r4   )r’   r#  r-  r.  rD  rN  r~   rO  r   rh   rH  rP  r$   rQ  rI  rŪ   r5   Ś_check_antecedentsĢ  s$  ,00$$’’*’
’’*’
’’ ’’"’’"’’
""’
’"’"’łž’$ž.’.’.’$$ž$ž ’ ’ ’ ’(’(’(’(’’’’’2222 
’ 
’,,,,6
ž6
ž0
ž0
ž.
ż0
ü6
ž6
ž0
ż0
ż0
ü0
ürv  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(((1/2, 0), ()), ((m/2,), (-m/2,)), s**(-2))/s**2
    c                 S   rŽ   )Nc                 S   s   g | ]}| qS r4   r4   rż   r4   r4   r5   r„     s    z(_int0oo.<locals>.neg.<locals>.<listcomp>r4   rā   r4   r4   r5   Śneg  r@   z_int0oo.<locals>.neg)rµ   rŚ   rM   r   rK   rŲ   rŁ   r&   )r-  r.  rE   r!  r  rN  rw  r5  r6  r/  r0  r4   r4   r5   Ś_int0oo’  s   rx  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                    r  )Nc                    s   g | ]}|   qS r4   r4   )r0   r{   r  r4   r5   r„   "  rē   z2_rewrite_inversion.<locals>.tr.<locals>.<listcomp>r4   rā   r  r4   r5   rä   !  r  z_rewrite_inversion.<locals>.trTr*  )rµ   rŚ   r   r&   rK   rŲ   rM   rŁ   )rP   rĖ   rĢ   rE   r  rZ   rä   r4   r  r5   Ś_rewrite_inversion  s   (’ry  c                    sv  ddl mmmm mmmm}m	}m
 td jt\}}|dk r5td ttS  f	dd fdd
ttjtjtjtjg\}}}}	|| | }
|	| | }|
| d	 }|	| 		d
krtj}n		d
krd
}n|}d
	 d	 |j  |j  	 j}td||||	|
||	f  td||f  j|d	 ksŹ|d
krÄ||	ksŹtd dS jD ]}jD ]}|| jrå||kråtd   dS qŅqĶ||	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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|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 }| 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   )
rh   Śimr   r   r÷   r   r   r   Śnanr  z#Checking antecedents for inversion:z  Flipping G.c                    s  t |\}}| |9 } ||| 9 }||9 }g }|| t d  }| | t d  }	|r9|}
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 )Nrs   r   rt   )rµ   r   )rZ   rz   r    r+   ZplusŚcoeffZexponentr#  ZwpZwmŚw)	r   r÷   r   r  r   r   rz  rh   rE   r4   r5   Śstatement_half2  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. TFr4   )rZ   rz   r    r+   )r   r~  r4   r5   Ś	statementD  s   ’z/_check_antecedents_inversion.<locals>.statementrs   rY   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<  r4   r¤   ©r  r+   r4   r5   r„   s  ó    z0_check_antecedents_inversion.<locals>.<listcomp>c                    s    fddj D  S )Nc                    r  r<  r4   r¤   r  r4   r5   r„   v  r  z;_check_antecedents_inversion.<locals>.E.<locals>.<listcomp>r@  rJ  )r   rĢ   r  rJ  r5   ŚEu  s   z'_check_antecedents_inversion.<locals>.Ec                    s     d  | S r¶   r4   rJ  )rP  r  rQ  r4   r5   ŚHx  r  z'_check_antecedents_inversion.<locals>.Hc                    ó     d  | dS )NrY   Tr4   rJ  ©rP  r~  rQ  r4   r5   ŚHp{  r`  z(_check_antecedents_inversion.<locals>.Hpc                    r  )NrY   Fr4   rJ  r  r4   r5   ŚHm~  r`  z(_check_antecedents_inversion.<locals>.Hm)r   rh   rz  r   r   r÷   r   r   r   r{  r  r  rŚ   rµ   Ś_check_antecedents_inversionrå   r   rŅ   rM   rK   rL   rN   r}   r×   r8  r   )rĢ   rE   r   r{  r  r¾   r“   r>   r~   r   r1  rw   rH  Śepsilonr×   rZ   rz   r  r  r  r  r#  r4   )r   r÷   r   r  r   r   rĢ   rz  rh   rP  r  r~  rQ  rE   r+   r5   r  '  s   00$’

ż(’.6ž’$$’&.ż(.ž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č   r&   rK   rŲ   rM   rŁ   )rĢ   rE   r{   rz   rZ   rÜ   r4   r4   r5   Ś_int_inversion   s   ,r  NTc           &         sh  ddl m}m}mm}m} tsi att t| t	raddl m
} || j| |”\}}	t|	dkr4dS |	d }	|	jrG|	j|ksD|	jjsFdS n|	|krMd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 ]\}}|||dddd	||< q|}t|ts¬| |”}|d
kr±qyt|ttfsæ|| |”}t|d
krĘqyt|tsĻ||}g }|D ]Q\}}t|| |” t|”dd	|}z| |” t|”}W n	 t yū   Y qÓw |||f   !| ”rqÓt	|j|j|j|j||jdd	}| "||f ” qÓ|r.||f  S qy|s4d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}z|| |||d
dd\}} }!||||| }W n |y   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Ü| !||”rāt#d dS t0 1|”}#g }|#D ]?} |  |”\}$}	t|	dkr’t2d|	d }t|j|\}"}%||$dt	|j|j|j|j|||"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.
    r   )rÉ   r\   r   Śzoor   )ŚfactorrY   NT)Śold)Zlift)Zexponents_onlyFz)Trying recursive Mellin transform method.)Śmellin_transformŚinverse_mellin_transformŚIntegralTransformErrorŚMellinTransformStripError)r   r{  r  ŚsimplifyŚcancelc                    sJ   z| |||dddW S   y$   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Śneedeval)r	   )ŚFr  rE   Śstrip)r  r  r  r  r4   r5   Śmy_imt  s   
’
ž’z_rewrite_single.<locals>.my_imtr  zrewrite-singlec                    sl   ddl m}m} t| |dd}|d ur.|\}}t||dd}t||f|| |d fdfS || |d fS )Nr   )ŚIntegralr   T)Śonly_doubleZnonrepsmall)Zrewrite)r   r  r   Ś_meijerint_definite_4Ś_my_unpolarifyr   )r3   rE   r  r   ru   r<   rQ   )r   r4   r5   Śmy_integrator  s   ’z&_rewrite_single.<locals>.my_integrator)Ś
integratorr  r  rZ   )r  r  r  z"Recursive Mellin transform failed.zUnexpected form...z"Recursive Mellin transform worked:)3r   rÉ   r\   r   r  r   Ś_lookup_tabler”   rĆ   r&   r  rŚ   rÆ   rŅ   r±   r²   r   r,  rK   rŲ   rM   rŁ   r   r+   rH   rÄ   Śitemsr  r   r  r   rµ   Ś
ValueErrorr;   rI   r  Zsympy.integrals.transformsr  r  r  r  r{  r  r  rš   rė   r§   rõ   r   rŹ   ŚNotImplementedError)&r3   rE   Ś	recursiverÉ   r\   r  r   r  r|  r“   Śf_r{   rć   rJ   ZtermsrQ   rR   r   Zsubs_r  r	  r<   rP   rĢ   r2  r  r  r{  r  r  r  r  r  r  rZ   r:   r    rz   r4   )r  r  r  r   r  r5   Ś_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   rY   N)rĶ   r„  )r3   rE   r£  rP   rĖ   rĢ   r4   r4   r5   Ś	_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}dD ]5}|D ]0\}}t| |}	t| |}
|	rk|
rkt|	d	 |
d	 }|d
krk|||	d |
d |f    S q;q7d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ó   rD   r4   r5   r6   W  r7   z_rewrite2.<locals>.<genexpr>Nc                    ó&   t tt| d  tt| d  S r  )ŚmaxrŅ   r¼   rę   rD   r4   r5   rF   ]  ó   & z_rewrite2.<locals>.<lambda>c                    r§  r  )rØ  rŅ   rĮ   rę   rD   r4   r5   rF   ^  r©  c                    r§  r  )rØ  rŅ   rČ   rę   rD   r4   r5   rF   _  s    ’©FTrY   Fr   )rĶ   rō   rĻ   rÓ   r   r(   r„  r   )r3   rE   rP   rĖ   rĢ   rć   r£  Zfac1Zfac2r-  r.  rQ   r4   rD   r5   Ś	_rewrite2N  s,   


żś’r«  c                 C   są   ddl m}m} g }tt| |tjhB tdD ]'}t|  	||| ”|}|s'q| 	||| ”}t
|||r;| |” q|  S |  t”rftd tt| |}|rft|turatt|| t”S | |” |rnt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&   )Śkeyś*Try rewriting hyperbolics in terms of exp.N)r   r¬  r&   ŚsortedrČ   r   r°   r*   Ś_meijerint_indefinite_1r   r.   rI   r;   r"   r  Śmeijerint_indefiniter!   rØ   r   r   r   rĄ   r   ŚextendŚnextr(   )r3   rE   r¬  r&   ŚresultsrZ   r<   Śrvr4   r4   r5   r±  l  s,   
’
’r±  c                    s&  ddl m}m}m}m} td| d t| }|du rdS |\}}}	}
td| tj}|	D ]§\}}}t	|j
\}}t	|\}}||7 }|| ||d| |    }|d | d  tdd	tj} fd
d}tdd ||jD rt||j||jdg ||jdg ||j| }nt||jdg ||j||j||jdg |}|jr»|  d” ||”s»d}nd}t| |||  ”|d}|t|| dd7 }q.fdd}||}|jr’g }|jD ]\}}
t||}|||
fg7 }qčt| }nt||}t|t|
f|| dfS )z0 Helper that does not attempt any substitution. r   )r  r    r{  r  z,Trying to compute the indefinite integral ofZwrtNz could rewrite:rY   r{   zmeijerint-indefinitec                    r(  )Nc                    s   g | ]}|  d  qS rą   r4   r¤   ©rH  r4   r5   r„   ²  rē   z7_meijerint_indefinite_1.<locals>.tr.<locals>.<listcomp>r4   rę   r¶  r4   r5   rä   ±  r)  z#_meijerint_indefinite_1.<locals>.trc                 s   s"    | ]}|j o|d kdkV  qdS )r   TN)r8  )r0   rz   r4   r4   r5   r6   ³  s     z*_meijerint_indefinite_1.<locals>.<genexpr>)ŚplaceTr*  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:

        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
        r   )r  F)ZdeeprY   )r   r  r
   r   Z
_from_argsZas_coeff_add)r<   r  rD   r4   r5   Ś_cleanÅ  s   z'_meijerint_indefinite_1.<locals>._clean)r   r  r    r{  r  r  r¦  r   r°   rµ   rŚ   rš   r   rō   rM   r&   rK   rŲ   rŁ   Zis_extended_nonnegativer   r;   r   r   r,   r:   r  r   )r3   rE   r  r    r{  r  rĪ   rP   rĖ   ŚglrQ   r<   rÜ   r  rĢ   rZ   rz   r  r    Zfac_r{   rä   ru   r·  rø  r  r³   r4   )rH  rE   r5   r°    sL   


.’.’
r°  c                 C   sī  ddl m}m}m}m}m}m}	 td| d|||f  |  |”r&td dS |  |	”r1td dS | |||f\}
}}}t	d}|  
||”} |}||krPtjd	fS g }|t u ri|turit|  
|| ”|| | S |t u rįtd
 t| |}td| t|td	dtjg D ]X}td| |jstd qt|  
||| ”|}|du rŖtd qt|  
||| ”|}|du r¾td q|\}}|\}}t|||}|dkrÖtd q|| }||f  S nŅ|tu rõt| ||t}|d  |d fS ||fdtfkrt| |}|rt|d tr| |” n|S n|tu r]t| |D ];}|| dkd	kr[td|  t|  
||| ”t|| |  |}|r[t|d trW| |” q!|  S q!|  
||| ”} || }d}|tkr|||| }t|}|  
||| ”} | t|| | 9 } t}td|| td|  t| |}|r³t|d tr±| |” n|S |
 t”rģtd tt|
|||}|rģt|tu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   )rO   r   r   r   r   ŚSingularityFunctionŚIntegratingzwrt %s from %s to %s.z+Integrand has DiracDelta terms - giving up.Nz5Integrand has Singularity Function terms - giving up.rE   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.rY   zTrying x -> x + %szChanged limits tozChanged function tor®  )$r   rO   r   r   r   r   rŗ  r  r;   r   r   r   r°   r   Śmeijerint_definiterČ   rÆ  r*   Zis_extended_realŚ_meijerint_definite_2r  r.   r&   rI   r   r   r"   r!   rØ   r   r   r   rĄ   r²  r³  r(   )r3   rE   rZ   rz   rO   r   r   r   r   rŗ  r¤  Zx_Za_Zb_rļ   r“  rĒ   r    Zres1Zres2Zcond1Zcond2rQ   r<   Śsplitru  rµ  r4   r4   r5   r½  ģ  sĄ    






ģ
ü
’’


’*
’r½  c           	      C   sō   ddl m} ddlm} | dfg}|d d }|h}t|}||vr.||dfg7 }| |” t|}||vrB||dfg7 }| |” | |t”r^t||}||vr^||dfg7 }| |” | t	t
”rxt|}||vrx||d	fg7 }| |” |S )
z6 Try to guess sensible rewritings for integrand f(x). r   )Śexpand_trig)ŚTrigonometricFunctionzoriginal integrandrt   r
   r	   zexpand_trig, expand_mulztrig power reduction)r   rĄ  Ś(sympy.functions.elementary.trigonometricrĮ  r
   rU   r	   r;   r"   r#   r$   r   )	r3   rE   rĄ  rĮ  r<   r  ZsawZexpandedZreducedr4   r4   r5   Ś_guess_expansionw  s0   




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.
    rE   zmeijerint-definite2T)Zpositiver   ZTryingN)rš   r   r   r°   rĆ  r  Ś_meijerint_definite_3)r3   rE   ZdummyrĢ   Zexplanationr<   r4   r4   r5   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.
    rY   Fz#Expanding and evaluating all terms.c                    r£   r4   )r  )r0   rĢ   rD   r4   r5   r„   Ā  r¦   z)_meijerint_definite_3.<locals>.<listcomp>c                 s   s    | ]}|d uV  qd S r-   r4   )r0   ru   r4   r4   r5   r6   Ć  s    z(_meijerint_definite_3.<locals>.<genexpr>N)r  Zis_Addr  r:   r9   r   r°   r   )r3   rE   r<   Zressr#  ru   r    r4   rD   r5   rÄ  ¶  s$   
õrÄ  c                 C   s   ddl m} t|| S )Nr   r`   )r   r\   r  )r3   r\   r4   r4   r5   r  Ī  s   r  c              
   C   s   t d|  |sot| |dd}|duro|\}}}}t d||| tj}|D ]0\}	}
} |	dkr.q$t||	 |||
  | |\}	} ||	t| | 7 }t|t| |}|dkrT nq$t|}|dkrbt d nt d| t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| |r||f  S t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»  F)r£  Nś#Could rewrite as single G function:r   ś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).)r  r¦  r   r°   r  r%  r   r  r  r   r«  r7  rv  rx  )r3   rE   r  rĪ   rP   rĖ   rĢ   rQ   r<   rÜ   r  r  r-  r.  r3  Śs1Śf1r4  Śs2Śf2ru   Zf1_Zf2_r4   r4   r5   r  Ó  sh   
’



’


är  c                 C   s~  ddl m}m}m}m}m}m} | }	|}
tddd}|  |
|”} t	d|  t
| |s0t	d dS tj}| jr<t| j}nt| |rE| g}nd}|rÜg }g }|rŌ| ” }t||r||}|jre||j7 }qMzt|jd |\}}W n ty|   d}Y nw |d	kr| |” nK| |” nE|jrĶ||}|jr||j7 }qM||jjvrĒz
t|j|\}}W n tyø   d}Y nw |d	krĒ| |||j ” | |” n| |” |sO|| }|| } || jvrt	d
| | ddl m}m} |||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rc nq6t!|}|dkrtt	d dS t	d| t!t"|}| #|”s|||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   )r   r	   rn   r   r   r   r{   Tr*  zLaplace-invertingzBut expression is not analytic.NrY   z.Expression consists of constant and exp shift:)r÷   rz  Fz3but shift is nonreal, cannot be a Laplace transformz1Result is a delta function, possibly conditional:rÅ  rĘ  z"Result before branch substitution:)ŚInverseLaplaceTransform)&r   r   r	   rn   r   r   r   r   r   r  rõ   r   r°   Zis_Mulr   r:   rĆ   Śpoprµ   r¬   rI   r±   r²   r§   r÷   rz  r   r   r¦  ry  r  r   r  r  r   r;   r  rĖ  )r3   rE   r{   r   r	   rn   r   r   r   r¤  Zt_Śshiftr:   r  ZexponentialsrO   r
  rZ   rz   r÷   rz  rQ   r<   rĪ   rP   rĖ   rĢ   rÜ   r  rĖ  r4   r4   r5   Śmeijerint_inversion  s°    




’
’
ć



’

’źrĪ  )Fr   )lr­   Śtypingr   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   r+  r   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"   rĀ  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timeitrH   r”  r¬   rµ   r¼   rĮ   rČ   rĶ   rĻ   rÓ   rŻ   rå   rč   rń   rš   rė   rõ   r  r  r  r  r  r%  r7  rv  rx  ry  r  r  r  r„  r¦  r«  r±  r°  r½  rĆ  r¾  rÄ  r  r  rĪ  r4   r4   r4   r5   Ś<module>   s    	 ["!$(	k

t
J  5y 
%[
 !F