ó
~9­\c           @  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/ m0 Z0 m1 Z1 d d l2 m3 Z3 d d l4 m5 Z5 m6 Z6 d d l7 m8 Z9 d d l: m; Z; e d ƒ Z< d „  Z= d „  Z> d d l? m@ Z@ e@ d ƒ ZA d „  ZB d eC f d „  ƒ  YZD d „  ZE d  „  ZF d! „  ZG d" „  ZH d# „  ZI d$ „  ZJ d% „  ZK d& „  ZL d' „  ZM d( „  ZN i  aO d) „  ZP d* „  ZQ d+ „  ZR d, „  ZS d- „  ZT eU d. „ ZV d/ „  ZW eU d0 „ ZX d1 „  ZY eU d2 „ ZZ d3 „  Z[ d4 „  Z\ d5 „  Z] d6 „  Z^ d7 „  Z_ e` aa e eA eb d8 „ ƒ ƒ Zc eb d9 „ Zd d: „  Ze d; „  Zf d< „  Zg eA d= „  ƒ Zh d> „  Zi d? „  Zj d@ „  Zk dA „  Zl eA eU dB „ ƒ Zm dC „  Zn dD S(E   s¿  
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
iÿÿÿÿ(   t   print_functiont   division(   t   oot   St   pit   Expr(   t   factor_terms(   t   expandt
   expand_mult   expand_power_base(   t   Add(   t   Mul(   t   range(   t   cacheit(   t   Dummyt   Wild(   t   hyperexpandt	   powdenestt   collect(   t   sincos_to_sum(   t   Andt   Ort   BooleanAtom(   t
   DiracDeltat	   Heaviside(   t   exp(   t	   Piecewiset   piecewise_fold(   t   _rewrite_hyperbolics_as_expt   HyperbolicFunction(   t   cost   sin(   t   meijerg(   t   multiset_partitionst   ordered(   t   debug(   t   default_sort_keyt   zc           sH   t  |  ƒ }  t |  d t ƒ r; t ‡  f d †  |  j Dƒ ƒ S|  j ˆ  Œ  S(   Nt   is_Piecewisec         3  s   |  ] } t  | ˆ  Œ Vq d  S(   N(   t   _has(   t   .0t   i(   t   f(    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pys	   <genexpr>=   s    (   R   t   getattrt   Falset   allt   argst   has(   t   resR*   (    (   R*   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR'   8   s    c   &        s´  d „  } t  t | d ƒ ƒ \ ‰ ‰
 ‰ ‰ } t d d d „  g ƒ‰ ˆ t ˆ
 ‰ ˆ t d ƒ t t ‡ f d † ‰ t ‡ f d † } d	 „  } ˆ | ˆ ƒ t t f g ˆ d  <d
 d l m ‰ m } m	 } d | f ‡ f d †  ƒ  Y} 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 †  ‰  ‡  ‡ ‡ ‡ ‡ ‡ f d †  } | d d ƒ | d d
 ƒ | t d ƒ d d ƒ | t d ƒ d d
 ƒ ‡  ‡ ‡ ‡ ‡ ‡
 ‡ f 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 †  ‰ ‡ ‡ ‡ f d †  ‰ | | ˆ ƒ ˆ t d ˆ ƒ ˆ t ƒ | | ˆ ƒ ˆ t ˆ d ƒ ˆ t ƒ ‡ ‡ f d †  } | | ˆ ƒ ˆ | t ƒ | | ˆ ˆ ƒ | | ˆ ƒ ƒ t d ƒ t d d g g  d g d g ˆ ˆ ƒ f g t ƒ | | t ˆ ˆ ƒ ƒ | | t ˆ ƒ ƒ ƒ ˆ	 t d d g t d ƒ d g d g d t d ƒ d g ˆ ˆ ƒ f g t ƒ 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 t ƒ ˆ | ˆ ƒ 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(!   s8    Add formulae for the function -> meijerg lookup table. c         S  s   t  |  d t g ƒS(   Nt   exclude(   R   R%   (   t   n(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   wildC   s    t   pqabcR2   t
   propertiesc         S  s   |  j  o |  d k S(   Ni    (   t
   is_Integer(   t   x(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   <lambda>F   t    i   c	   	   	     sM   ˆ  j  t |  t ƒ g  ƒ j |  | t | | | | | ƒ f g | | f ƒ d  S(   N(   t
   setdefaultt   _mytypeR%   t   appendR    (	   t   formulat   ant   apt   bmt   bqt   argt   fact   condt   hint(   t   table(    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   addI   s    c           s2   ˆ  j  t |  t ƒ g  ƒ j |  | | | f ƒ d  S(   N(   R:   R;   R%   R<   (   R=   t   instRD   RE   (   RF   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   addiM   s    c         S  sF   |  t  d g g  g  d g t ƒ f |  t  g  d g d g g  t ƒ f g S(   Ni   i    (   R    R%   (   t   a(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   constantQ   s    !iÿÿÿÿ(   t
   unpolarifyt   Functiont   Nott   IsNonPositiveIntegerc             s   e  Z e ‡  f d  †  ƒ Z RS(   c           s)   ˆ  | ƒ } | j  t k r% | d k Sd  S(   Ni    (   R6   t   True(   t   clsRB   (   RL   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   eval\   s    (   t   __name__t
   __module__t   classmethodRR   (    (   RL   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyRO   Z   s   (   t   gammaR   R   R   t   reR   t   sinct   sqrtt   sinht   cosht	   factorialt   logt   erft   erfct   erfit
   polar_lifti    RE   i   c           s,   ˆ  t  d ƒ d | | d d d |  S(   Ni   i   (   R   (   t   rt   signt   nu(   R   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   A1v   s    c           sª   ˆ ˆ ˆ d ˆ ƒ | ˆ ˆ ˆ d ˆ |  d ˆ d d d |  ˆ d g g  ˆ | ˆ d g ˆ | ˆ d g ˆ ˆ d ˆ ˆ d |  ˆ  |  | ˆ ƒ ƒ d  S(   Ni   i   (    (   Rb   t   sgn(   Re   RJ   RG   t   bRY   t   t(    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   tmpaddy   s    0$/c           sÂ   ˆ ˆ ˆ ˆ t  ˆ ƒ | ˆ ˆ ƒ t  ˆ d ˆ ˆ ˆ t  ˆ |  d |  | ˆ d g d |  | ˆ d g d t d ƒ d g g  ˆ t  ˆ ˆ ˆ ˆ d |  ˆ  |  | ˆ ƒ ƒ d  S(   Ni   i   i    (   R%   R   (   Rb   Rf   (   Re   RJ   RG   Rg   t   pt   qRY   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyRi   …   s    JBi   i   c           sM   |  ˆ } d | ˆ  | ƒ t  g  d g | d d g | d g  ˆ ƒ f g S(   Niÿÿÿÿi   i    (   R    (   t   subst   N(   R\   R2   Rh   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   make_log1    s    
c           sE   |  ˆ } ˆ  | ƒ t  d g | d g  g  d g | d ˆ ƒ f g S(   Ni   i    (   R    (   Rl   Rm   (   R\   R2   Rh   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   make_log2¥   s    
	c           s   ˆ  |  ƒ ˆ |  ƒ S(   N(    (   Rl   (   Rn   Ro   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   make_log3¯   s    (	   t   Eit   It   expintt   Sit   Cit   Shit   Chit   fresnelst   fresnelcs   3/2i   (   t   besseljt   besselyt   besselit   besselk(   t
   elliptic_kt
   elliptic_eN(    (.   t   listt   mapR   R%   R   RP   t   sympyRL   RM   RN   RV   R   R   R   RW   R   RX   RY   RZ   R[   R\   R]   R^   R_   R`   Ra   R   R   t   absR    Rq   Rr   Rs   Rt   Ru   Rv   Rw   Rx   Ry   Rz   R{   R|   R}   R~   R   t   Half(&   RF   R3   t   cRI   RK   RM   RN   RO   RV   R   R   RW   R   RX   RZ   R[   R]   R^   R_   R`   Ra   Ri   Rp   Rq   Rr   Rs   Rt   Ru   Rv   Rw   Rx   Ry   Rz   R{   R|   R}   R~   R   (    (   Re   RJ   RG   Rg   R\   Rn   Ro   R2   Rj   R   Rk   RY   Rh   RF   RL   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _create_lookup_tableA   sž    	$!		j9(9(E(E(AHE9!!)Nb@@D((D+I	@/JKWS/CCO\\"9QRF8(   t   timethisR    c         C  s   | |  j  k r d S|  j r) t |  ƒ f Sg  |  j D] } t | | ƒ ^ q3 } g  } x | D] } | t | ƒ 7} q[ W| j ƒ  t | ƒ Sd S(   s4    Create a hashable entity describing the type of f. N(    (   t   free_symbolst   is_Functiont   typeR.   R;   R€   t   sortt   tuple(   R*   R7   RJ   t   typesR0   Rh   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR;     s    	%
t   _CoeffExpValueErrorc           B  s   e  Z d  Z RS(   sD   
    Exception raised by _get_coeff_exp, for internal use only.
    (   RS   RT   t   __doc__(    (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyRŽ   .  s   c         C  s´   d d l  m } t | |  ƒ ƒ j | ƒ \ } } | sG | t d ƒ f S| \ } | j r„ | j | k rw t d ƒ ‚ n  | | j f S| | k r  | t d ƒ f St d |  ƒ ‚ d S(   sq  
    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)
    iÿÿÿÿ(   t   powsimpi    s   expr not of form a*x**bi   s   expr not of form a*x**b: %sN(	   R‚   R   R	   t   as_coeff_mulR   t   is_Powt   baseRŽ   R   (   t   exprR7   R   R…   t   m(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _get_coeff_exp5  s    !		c           s,   ‡  f d †  ‰  t  ƒ  } ˆ  |  | | ƒ | S(   st  
    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           sw   |  | k r  | j  d g ƒ d  S|  j rO |  j | k rO | j  |  j g ƒ d  Sx! |  j D] } ˆ  | | | ƒ qY Wd  S(   Ni   (   t   updateR’   R“   R   R.   (   R”   R7   R0   RB   (   t   _exponents_(    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR˜   d  s    (   t   set(   R”   R7   R0   (    (   R˜   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt
   _exponentsT  s    		c           s3   d d l  m } t ‡  f d †  |  j | ƒ Dƒ ƒ S(   sB    Find the types of functions in expr, to estimate the complexity. iÿÿÿÿ(   RM   c         3  s'   |  ] } ˆ  | j  k r | j Vq d  S(   N(   Rˆ   t   func(   R(   t   e(   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pys	   <genexpr>u  s    (   R‚   RM   R™   t   atoms(   R”   R7   RM   (    (   R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt
   _functionsr  s    c           s`   g  d D] } t  | d ˆ g ƒ^ q \ ‰ ‰ ‡  ‡ ‡ ‡ f d †  ‰  t ƒ  } ˆ  |  | ƒ | S(   sX  
    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}
    t   pqR1   c           s   t  |  t ƒ s d  S|  j ˆ ˆ ˆ ƒ } | r^ | ˆ d k r^ | j | ˆ | ˆ ƒ d  S|  j rk d  Sx |  j D] } ˆ  | | ƒ qu Wd  S(   Ni    (   t
   isinstanceR   t   matchRG   t   is_AtomR.   (   R”   R0   R•   RB   (   t   compute_innermostRj   Rk   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR£   ‰  s    	(   R   R™   (   R”   R7   R2   t	   innermost(    (   R£   Rj   Rk   R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _find_splitting_pointsx  s
    .	c         C  sa  d d l  m } m } t d ƒ } t d ƒ } t d ƒ } t |  ƒ }  t j |  ƒ } xü | D]ô } | | k r{ | | 9} q\ | | j k r— | | 9} q\ | j rF| | j	 j k rF| j
 j | ƒ \ }	 }
 |
 | f k rú t | j
 ƒ j | ƒ \ }	 }
 n  |
 | f k rF| | | j	 9} | | | |	 | j	 d t ƒƒ 9} q\ qFn  | | 9} q\ W| | | f S(   sV  
    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))
    iÿÿÿÿ(   t   polarifyRL   i   Rl   (   R‚   R¦   RL   R   R	   R   t	   make_argsRˆ   R’   R   R“   R‘   R   R,   (   R*   R7   R¦   RL   RC   t   pot   gR.   RJ   R…   Rh   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt
   _split_mul™  s*    !#	c         C  s’   t  j |  ƒ } g  } xv | D]n } | j r} | j j r} | j } | j } | d k  ri | } d | } n  | | g | 7} q | j | ƒ q W| S(   sÌ   
    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.
    i    i   (   R   R§   R’   R   R6   R“   R<   (   R*   R.   t   gsR©   R2   R“   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   _mul_args¾  s    		c         C  sy   t  |  ƒ } t | ƒ d k  r" d St | ƒ d k rA t | ƒ g Sg  t | d ƒ D]$ \ } } t | Œ  t | Œ  f ^ qQ S(   s_  
    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))]
    i   N(   R¬   t   lent   NoneRŒ   R!   R   (   R*   R«   R7   t   y(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _mul_as_two_partsÕ  s    c      
   C  sÀ   d „  } t  t |  j ƒ t |  j ƒ ƒ } | d |  j | d } | d t | d |  j } | t | |  j | ƒ | |  j	 | ƒ | |  j
 | ƒ | |  j | ƒ |  j | | | | ƒ f S(   sO    Return C, h such that h is a G function of argument z**n and
        g = C*h. c         S  sG   g  } x: |  D]2 } x) t  | ƒ D] } | j | | | ƒ q  Wq W| S(   s5    (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) (   R   R<   (   t   paramsR2   R0   RJ   R)   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   inflateó  s
    i   i   (   R   R­   R?   RA   Rd   R   t   deltaR    R>   t   aotherR@   t   bothert   argument(   R©   R2   R²   t   vt   C(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt
   _inflate_gî  s    	"$c         C  sJ   d „  } t  | |  j ƒ | |  j ƒ | |  j ƒ | |  j ƒ d |  j ƒ S(   sQ    Turn the G function into one of inverse argument
        (i.e. G(1/x) -> G'(x)) c         S  s   g  |  D] } d | ^ q S(   Ni   (    (   t   lRJ   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   tr  s    i   (   R    R@   Rµ   R>   R´   R¶   (   R©   R»   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _flip_g  s    	c         C  sð   | d k  r  t  t |  ƒ | ƒ St | j ƒ } t | j ƒ } t |  | ƒ \ } }  |  j } | d t d | d | t d ƒ d } | | | } g  t | ƒ D] } | d | ^ q¤ } | t	 |  j
 |  j |  j t |  j ƒ | | ƒ f S(   sX  
    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.
    i    i   i   (   t   _inflate_fox_hR¼   R   Rj   Rk   R¹   R¶   R   R   R    R>   R´   R@   R€   Rµ   (   R©   RJ   Rj   Rk   t   DR%   R2   t   bs(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR½     s    	-'c         K  s2   t  |  | |  } | | j k r. t |  |  S| S(   s¶   
    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.
    (   t   _dummy_Rˆ   R   (   t   namet   tokenR”   t   kwargst   d(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _dummy'  s    c         K  s<   |  | f t  k r. t |  |  t  |  | f <n  t  |  | f S(   s`   
    Return a dummy associated to name and token. Same effect as declaring
    it globally.
    (   t   _dummiesR   (   RÁ   RÂ   RÃ   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyRÀ   3  s    c           s=   d d l  m } m } t ‡  f d †  |  j | | ƒ Dƒ ƒ S(   sŠ    Check if f(x), when expressed using G functions on the positive reals,
        will in fact agree with the G functions almost everywhere iÿÿÿÿ(   R   t   Absc         3  s   |  ] } ˆ  | j  k Vq d  S(   N(   Rˆ   (   R(   R”   (   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pys	   <genexpr>B  s    (   R‚   R   RÇ   t   anyR   (   R*   R7   R   RÇ   (    (   R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _is_analytic>  s    c           sF  d d l  m } m } m } m ‰ m } m } m } m ‰  m	 ‰ m
 ‰ m ‰ d d l m } t |  | ƒ so |  S|  j t t t |  j ƒ ƒ Œ  }  t } | 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t } xv|
 D]n\ } } | j |  j k rÀqœn  xGt |  j ƒ D]6\ } } |	 | j d j k r| j | j d	 ƒ } d	 } n d } | j | j d ƒ } | s9qÐn  g  | j |  | j | d	 D] } | j | ƒ ^ qV} | g } x| D]} xü t |  j ƒ D]ë \ } } | | k rµq—n  | | k rÒ| | g 7} Pn  t | t ƒ r*| j d	 |	 k r*t | t ƒ r*| j d | j k r*| | g 7} Pn  t | t ƒ r—| j d |	 k r—t | t ƒ r—| j d	 | j k r—| | g 7} Pq—q—WqWt | ƒ t | ƒ d	 k r¬qÐn  g  t |  j ƒ D] \ } } | | k r¼| ^ q¼| j | ƒ g } |  j | Œ  }  t } PqÐWqœWq‰W‡  ‡ ‡ ‡ ‡ ‡ ‡ f d
 †  } |  j d „  | ƒ S(   sÒ  
    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
    iÿÿÿÿ(   t   symbolsR   t   Eqt   unbranched_argumentt	   exp_polarR   Rr   RB   t   periodic_argumentR   Ra   (   t   BooleanFunctions   p q rRQ   i   i    iþÿÿÿi   c           s×   |  j  d k r |  j } n |  j d k r6 |  j  } n |  S| j ˆ  ˆ ƒ ˆ ƒ } | s{ | j ˆ ˆ ˆ ƒ ˆ ƒ ƒ } n  | sÉ t | ˆ ƒ rÅ | j d j rÅ | j d ˆ k rÅ | j d d k S|  S| ˆ d k S(   Ni    i   (   t   lhst   rhsR¡   R    R.   t   is_polar(   t   origR”   R•   (   RB   R   Rj   RÎ   Ra   Rk   RÌ   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   repl_eq•  s    " c         S  s   |  j  o |  j d k S(   Ns   ==(   t   is_Relationalt   rel_op(   R”   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR8   ¦  R9   (   R‚   RÊ   R   RË   RÌ   RÍ   R   Rr   RB   RÎ   R   Ra   t   sympy.logic.boolalgRÏ   R    R›   R€   R   t	   _condsimpR.   RP   R   R   Rƒ   R,   t	   enumerateRˆ   R¡   Rl   R­   t   replace(   RD   RÊ   R   RË   RÍ   R   Rr   RÏ   t   changeRb   t   rulest   frot   toR2   t   arg1R•   t   numR7   t	   otherargst	   otherlistt   arg2t   kt   arg3t   arg_t   newargsRÔ   (    (   RB   R   Rj   RÎ   Ra   Rk   RÌ   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyRØ   E  sx    L!'8@*$+(3		8	"%"%(!c         C  s#   t  |  t ƒ r |  St |  j ƒ  ƒ S(   s    Re-evaluate the conditions. (   R    t   boolRØ   t   doit(   RD   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt
   _eval_condª  s    c         C  sA   d d l  m } | |  | ƒ } | s= | j | d „  ƒ } n  | S(   sû    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. iÿÿÿÿ(   t   principal_branchc         S  s   |  S(   N(    (   R7   R¯   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR8   ¾  R9   (   R‚   Rë   RÚ   (   R”   t   periodt   full_pbRë   R0   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _my_principal_branchµ  s
    c   	        sÂ   t  | | ƒ \ } ‰ t  | j | ƒ \ } ‰  | j ƒ  } t | | ƒ } |  t ˆ  ƒ | ˆ d ˆ  d } ‡  ‡ f d †  } | t | | j ƒ | | j ƒ | | j ƒ | | j	 ƒ | | ƒ f S(   s”   
    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.
    i   c           s'   g  |  D] } | d ˆ ˆ  d ^ q S(   Ni   (    (   Rº   RJ   (   Rg   t   s(    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR»   Ñ  s    (
   R–   R¶   t
   get_periodRî   Rƒ   R    R>   R´   R@   Rµ   (	   RC   R¨   R©   R7   t   _RJ   Rì   R¸   R»   (    (   Rg   Rï   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _rewrite_saxena_1Â  s    $6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 „  } t t | |  j ƒ | |  j ƒ | |  j ƒ | |  j ƒ | |
 ƒ | ƒ Sg  } x+ |  j D]  } | | | ƒ d k  g 7} qWx. |  j D]# } | d d | | ƒ k  g 7} q?Wt | Œ  } x+ |  j D]  } | | | ƒ d k  g 7} q|Wx. |  j D]# } | d d | | ƒ k  g 7} qªWt | Œ  } | |  j ƒ | d | d | | k } 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 } xP t | |	 d ƒ d ƒ D]4 } | | t | |
 ƒ ƒ |	 d | t ƒ g 7} qPW|	 d k t | |
 ƒ ƒ |	 t k  g } | |
 d ƒ | g } | rÔg  } n  x2 | | | g D]! }  | t |  | | Œ  g 7} qäW| | 7} | d | ƒ | g } | r8g  } n  t | | d ƒ | d | k | | k t | |
 ƒ ƒ |	 t k  | Œ g }! | |! 7} | d |! ƒ | | g } | r´g  } n  t | | k  d | k |	 d k | t | |
 ƒ ƒ |	 t ƒ | Œ g }" |" t | | d k | |	 d ƒ | t | |
 ƒ ƒ d ƒ | Œ g 7}" | |" 7} | d |" ƒ g  }# |# | | | ƒ | |	 d ƒ | | |
 ƒ d ƒ | |
 d ƒ g 7}# | s±|# | g 7}# n  g  }$ x4 t |  j |  j ƒ D] \ } } |$ | | g 7}$ qÍW|# | t |$ Œ  ƒ d k  g 7}# t |# Œ  }# | |# g 7} | d |# g ƒ t |	 d k t | |
 ƒ ƒ |	 t k  ƒ g }% | sz|% | g 7}% n  t |% Œ  }% | |% g 7} | d |% g ƒ t | Œ  S(   sL  
    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.
    iÿÿÿÿ(   RË   RN   t   ceilingt   NeRW   RÌ   c         S  s   g  |  D] } d | ^ q S(   Ni   (    (   Rº   R7   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR»   ê  s    i   i   c          W  s   t  |  Œ  d  S(   N(   t   _debug(   t   msg(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR#   ÿ  s    s$   Checking antecedents for 1 function:s*     delta=%s, eta=%s, m=%s, n=%s, p=%s, q=%ss     ap = %s, %ss     bq = %s, %ss"     cond_3=%s, cond_3*=%s, cond_4=%si    s	     case 1:s	     case 2:s	     case 3:s     extra case:s     second extra case:(   R‚   RË   RN   Ró   Rô   RW   RÌ   R³   R–   R¶   R   R­   R@   R>   R?   RA   t   _check_antecedents_1R    Rµ   R´   R   Rd   R€   R   Rƒ   R   t   zipR
   R   (&   R©   R7   t   helperRË   RN   Ró   Rô   RW   RB   R³   t   etaRñ   R•   R2   Rj   Rk   t   xiR»   t   tmpRg   RJ   t   cond_3t   cond_3_start   cond_4R#   t   condst   case1t   tmp1t   tmp2t   tmp3Rä   t   extraRh   t   case2t   case3t
   case_extraRï   t   case_extra_2(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR÷   ×  sš    .	H	"!!*	
&&!P!2(	
		%%
	:D
@".c   
      C  sö   d d l  m } m } m } t |  j | ƒ \ } } d | } x% |  j D] } | | | d ƒ 9} qH Wx) |  j D] }	 | | d |	 d ƒ 9} qp Wx) |  j D] } | | d | d ƒ } qœ Wx% |  j	 D] }	 | | |	 d ƒ } qÈ W| | | ƒ ƒ S(   sc  
    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))
    iÿÿÿÿ(   RV   t	   gammasimpRL   i   (
   R‚   RV   R
  RL   R–   R¶   R@   R>   Rµ   R´   (
   R©   R7   RV   R
  RL   Rú   Rñ   R0   Rg   RJ   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   _int0oo_1L  s    
c           sb  d d l  m } ‡ ‡ f d †  } t | ˆ ƒ \ } }	 t | j ˆ ƒ \ } }
 t | j ˆ ƒ \ } } |
 d k  t k r |
 }
 t | ƒ } n  | d k  t k r· | } t | ƒ } n  |
 j sË | j rÏ d S|
 j |
 j } } | j | j } } | | | | | ƒ } | | | } | | | } t	 | | ƒ \ } } t	 | | ƒ \ } } | | ƒ } | | ƒ } |  | | 9}  t | j ˆ ƒ \ } } t | j ˆ ƒ \ } } |	 d | d ‰  |  t
 | ƒ | ˆ  }  ‡  f d †  } t | | j ƒ | | j ƒ | | j ƒ | | j ƒ | ˆ ƒ } t | j | j | j | j | ˆ ƒ } t |  d t ƒ| | f S(	   sŽ  
    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)
    iÿÿÿÿ(   t   ilcmc      	     sZ   t  |  j ˆ ƒ \ } } |  j ƒ  } t |  j |  j |  j |  j t | | ˆ  ƒ ˆ | ƒ S(   N(	   R–   R¶   Rð   R    R>   R´   R@   Rµ   Rî   (   R©   RJ   Rg   t   per(   Rí   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   pb}  s    i    Ni   c           s   g  |  D] } | ˆ  ^ q S(   N(    (   Rº   RJ   (   R   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR»   ¢  s    t   polar(   t   sympy.core.numbersR  R–   R¶   RP   R¼   t   is_RationalRj   Rk   R¹   Rƒ   R    R>   R´   R@   Rµ   R   (   RC   R¨   t   g1t   g2R7   Rí   R  R  Rñ   Rï   t   b1t   b2t   m1t   n1t   m2t   n2t   taut   r1t   r2t   C1t   C2t   a1Rg   t   a2R»   (    (   R   Rí   R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _rewrite_saxenag  s>    @(c   7        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
 †  } | ƒ  } t g  ˆ j D]0 } ˆ j D]  } | d | | ƒ d k ^ qq‚Œ  } t g  ˆ j D]0 } ˆ j D]  } | d | | ƒ d6 k  ^ qÕqÈŒ  } t g  ˆ j D]= } ˆ ˆ | d | d ƒ | | ƒ t d ƒ d k ^ qŒ  } t g  ˆ j D]9 } ˆ ˆ | d | ƒ | | ƒ t d ƒ d k ^ qaŒ  } t g  ˆ j D]= } ˆ ˆ | d | d ƒ | | ƒ t d ƒ d k ^ q°Œ  } t g  ˆ j D]9 } ˆ ˆ | d | ƒ | | ƒ t d ƒ d k ^ qŒ  }  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 †  }+ 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 |* |, ƒ }* yRˆ ˆ t ˆ ƒ d ˆ ˆ | ˆ ƒ ˆ ˆ t ˆ ƒ d ˆ ˆ | ˆ
 ƒ }- t |- d k ƒ t k r“|- d k }. nÕ‡ ‡ ‡ ‡ ‡ ‡	 ‡
 ‡ ‡ f	 d †  }/ t |/ d 
d 
ƒ |/ d d ƒ t | | ˆ ƒ d ƒ | | ˆ ƒ d ƒ ƒ f |/ |	 | ˆ ƒ ƒ d 
ƒ |/ |	 | ˆ ƒ ƒ d ƒ t | | ˆ ƒ d ƒ | | ˆ ƒ d ƒ ƒ f |/ d 
|	 | ˆ ƒ ƒ ƒ |/ d |	 | ˆ ƒ ƒ ƒ t | | ˆ ƒ d ƒ | | ˆ ƒ d ƒ ƒ f |/ |	 | ˆ ƒ ƒ |	 | ˆ ƒ ƒ ƒ t f ƒ }0 |- d k t | |- d ƒ | |0 d ƒ | | ƒ d k ƒ t | |- d ƒ | |0 d ƒ | | ƒ d k ƒ g }1 t |1 Œ  }. Wn t k
 r‚	t }. n Xx¬ | 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] \ }2 } t d | |2 ƒ q
Wg  ‰ ‡ f d †  }3 ˆ t | | | | d k | j t k | j t k | | | |# |% ƒ g 7‰ |3 d ƒ ˆ t | ˆ ˆ ƒ | | d ƒ | j t k ˆ j t k | | ƒ d k  | | | |% ƒ	 g 7‰ |3 d ƒ ˆ t | ˆ ˆ ƒ | | d ƒ | j t k ˆ j t k | | ƒ d k  | | | |# ƒ	 g 7‰ |3 d ƒ ˆ t | ˆ ˆ ƒ | ˆ ˆ ƒ | | d ƒ | | d ƒ ˆ j t k ˆ j t k | | ƒ d k  | | ƒ d k  | ˆ ˆ ƒ | | | ƒ g 7‰ |3 d ƒ ˆ t | ˆ ˆ ƒ | ˆ ˆ ƒ | | d ƒ | | d ƒ ˆ j t k ˆ j t k | | | ƒ d k  | ˆ ˆ ƒ | | | ƒ g 7‰ |3 d ƒ ˆ t ˆ ˆ k | j t k | j t k | d k | | | | |# |& ƒ
 g 7‰ |3 d ƒ ˆ t ˆ ˆ k  | j t k | j t k | d k | | | | |# |& ƒ
 g 7‰ |3 d ƒ ˆ t ˆ ˆ k | j t k | j t k | d k | | | |  |$ |% ƒ
 g 7‰ |3 d ƒ ˆ t ˆ ˆ k  | j t k | j t k | d k | | | | |$ |% ƒ
 g 7‰ |3 d ƒ ˆ t ˆ ˆ k | ˆ ˆ ƒ | | d ƒ | d k ˆ j t k | | ƒ d k  | | | | |& ƒ g 7‰ |3 d ƒ ˆ t ˆ ˆ k  | ˆ ˆ ƒ | | d ƒ | d k ˆ j t k | | ƒ d k  | | | | |& ƒ g 7‰ |3 d ƒ ˆ t | ˆ ˆ ƒ ˆ ˆ k | d k | | d ƒ ˆ j t k | | ƒ d k  | | | |  |$ ƒ g 7‰ |3 d ƒ ˆ t | ˆ ˆ ƒ ˆ ˆ k  | d k | | d ƒ ˆ j t k | | ƒ d k  | | | | |$ ƒ g 7‰ |3 d ƒ ˆ t ˆ ˆ k  ˆ ˆ k | d k | d k | | | | |  |$ |& ƒ g 7‰ |3 d ƒ ˆ t ˆ ˆ k ˆ ˆ k  | d k | d k | | | | | |$ |& ƒ g 7‰ |3 d ƒ ˆ t ˆ ˆ k ˆ ˆ k | d k | d k | | | | |  |! |$ |& |* ƒ g 7‰ |3 d ƒ ˆ t ˆ ˆ k  ˆ ˆ k  | d k | d k | | | | | |" |$ |& |* ƒ g 7‰ |3 d ƒ ˆ t | | d ƒ | j t k | j t k | j t k | | |# ƒ g 7‰ |3 d ƒ ˆ t | | d ƒ | j t k | j t k | j  t k | | |# ƒ g 7‰ |3 d  ƒ ˆ t | | d ƒ | j t k | j t k | j  t k | | |% ƒ g 7‰ |3 d! ƒ ˆ t | | d ƒ | j t k | j t k | j t k | | |% ƒ g 7‰ |3 d" ƒ ˆ t | | | d ƒ | j t k | j t k | | | |# |% ƒ g 7‰ |3 d# ƒ ˆ t | | | d ƒ | j t k | j t k | | | |# |% ƒ g 7‰ |3 d$ ƒ t! ˆ | d% t ƒ}4 t! ˆ | d% t ƒ}5 ˆ t |5 | | d ƒ ˆ | k  | j t k |# | | | ƒ g 7‰ |3 d& ƒ ˆ t |5 | | d ƒ ˆ | k  | j t k |# | | | ƒ g 7‰ |3 d' ƒ ˆ t |4 | | d ƒ ˆ | k  | j t k |% | | | ƒ g 7‰ |3 d( ƒ ˆ t |4 | | d ƒ ˆ | k  | j t k |% | | | ƒ g 7‰ |3 d) ƒ t ˆ Œ  }6 t |6 ƒ t k rP|6 Sˆ t | | ˆ k | | d ƒ | | d ƒ | j t k | j t k | j  t k t | ˆ ƒ ƒ | | ˆ d t k  | | |# |* |. ƒ g 7‰ |3 d* ƒ ˆ t | | ˆ k | | d ƒ | | d ƒ | j t k | j t k | j  t k t | ˆ ƒ ƒ | | ˆ d t k  | | |# |* |. ƒ g 7‰ |3 d+ ƒ ˆ t | ˆ ˆ d ƒ | | d ƒ | | d ƒ | j t k | j t k | d k | t t | ˆ ƒ ƒ k  | | |# |* |. ƒ g 7‰ |3 d, ƒ ˆ t | ˆ ˆ d ƒ | | d ƒ | | d ƒ | j t k | j t k | d k | t t | ˆ ƒ ƒ k  | | |# |* |. ƒ g 7‰ |3 d- ƒ ˆ t ˆ ˆ d k  | | d ƒ | | d ƒ | j t k | j t k | d k | t t | ˆ ƒ ƒ k  t | ˆ ƒ ƒ | | ˆ d t k  | | |# |* |. ƒ g 7‰ |3 d. ƒ ˆ t ˆ ˆ d k | | d ƒ | | d ƒ | j t k | j t k | d k | t t | ˆ ƒ ƒ k  t | ˆ ƒ ƒ | | ˆ d t k  | | |# |* |. ƒ g 7‰ |3 d/ ƒ ˆ t | | d ƒ | | d ƒ | | d k | j t k | j t k | j  t k t | ˆ ƒ ƒ | | ˆ d t k  | | |% |* |. ƒ g 7‰ |3 d0 ƒ ˆ t | | d ƒ | | d ƒ | | ˆ k | j t k | j t k | j  t k t | ˆ ƒ ƒ | | ˆ d t k  | | |% |* |. ƒ g 7‰ |3 d1 ƒ ˆ t | | d ƒ | | d ƒ | ˆ ˆ d ƒ | j t k | j t k | d k | t t | ˆ ƒ ƒ k  t | ˆ ƒ ƒ | d t k  | | |% |* |. ƒ g 7‰ |3 d2 ƒ ˆ t | | d ƒ | | d ƒ | ˆ ˆ d ƒ | j t k | j t k | d k | t t | ˆ ƒ ƒ k  t | ˆ ƒ ƒ | d t k  | | |% |* |. ƒ g 7‰ |3 d3 ƒ ˆ t | | d ƒ | | d ƒ ˆ ˆ d k  | j t k | j t k | d k | t t | ˆ ƒ ƒ k  t | ˆ ƒ ƒ | | ˆ d t k  | | |% |* |. ƒ g 7‰ |3 d4 ƒ ˆ t | | d ƒ | | d ƒ ˆ ˆ d k | j t k | j t k | d k | t t | ˆ ƒ ƒ k  t | ˆ ƒ ƒ | | ˆ d t k  | | |% |* |. ƒ g 7‰ |3 d5 ƒ t ˆ Œ  S(7   s>    Return a condition under which the integral theorem applies. iÿÿÿÿ(	   RW   RË   Rô   R   Rr   R   R   Rc   RL   (   RB   RÌ   i   i   s   Checking antecedents:s1     sigma=%s, s=%s, t=%s, u=%s, v=%s, b*=%s, rho=%ss1     omega=%s, m=%s, n=%s, p=%s, q=%s, c*=%s, mu=%s,s"     phi=%s, eta=%s, psi=%s, theta=%sc            sc   x\ ˆ  ˆ g D]N }  xE |  j  D]: } x1 |  j D]& } | | } | j r- | j r- t Sq- Wq Wq Wt S(   N(   R>   R@   t
   is_integert   is_positiveR,   RP   (   R©   R)   t   jt   diff(   R  R  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _c1Í  s    
i    i   c           s&   |  d k o% t  ˆ  d |  ƒ ƒ t k  S(   s¶  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)`
            i   (   Rƒ   R   (   R%   (   Ræ   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _condø  s    
c           sX   |  ˆ ˆ t  ˆ  ƒ d ˆ ˆ ˆ ˆ ƒ | ˆ ˆ t  ˆ ƒ d ˆ ˆ ˆ ˆ ƒ S(   Ni   (   Rƒ   (   t   c1t   c2(	   t   omegaRj   t   psiRk   t   sigmaR   t   thetat   uR·   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   lambda_s0$  s    +i   i   i   i   i   i	   i
   i   i   i   i   i   s     c%s:c           s   t  d |  ˆ  d ƒ d  S(   Ns
     case %s:iÿÿÿÿ(   Rõ   (   t   count(   R   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   pr=  s    i   i   i   i   i   i   i   i   Rù   t   E1t   E2t   E3t   E4i   i   i   i   i   i   i   i   i    i!   i"   i#   i   ("   R‚   RW   RË   Rô   R   Rr   R   R   Rc   RL   RB   RÌ   R–   R¶   R   R­   R@   R>   R?   RA   Rd   R   Rƒ   Rõ   R   R   Rê   R,   R   RP   t	   TypeErrorR#  t   is_negativeR÷   (7   R  R  R7   RW   RË   Rô   R   Rr   R   Rc   RL   RB   Rñ   Rï   Rh   R•   R2   t   bstart   cstart   rhot   mut   phiRú   R&  R(  R)   R$  R)  t   c3t   c4t   c5t   c6t   c7t   c8t   c9t   c10t   c11t   c12t   c13t   z0t   zost   zsot   c14R'  t   c14_altt   lambda_ct   c15R/  t   lambda_sRü   RD   R1  t
   mt1_existst
   mt2_existsRb   (    (   Ræ   R   R  R  R*  Rj   R+  Rk   R,  R   R-  R.  R·   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _check_antecedentsª  s®   @HH**
	FFSOSO11*' 6 6	
'+'-2-2-0	-3
9-4?
E
E
66
6+
0
0
0
0
<(
<(
<(
<(
*
*
*%
*%
I
I
I
I
.
.
@
@
@
@
O%
O%
F"
F"
C"%
F%
O%
O%
F"
F"
F%
F%
c         C  sÇ   t  |  j | ƒ \ } } t  | j | ƒ \ } } d „  } | |  j ƒ t | j ƒ } t | j ƒ | |  j ƒ } | |  j ƒ t | j ƒ }	 t | j ƒ | |  j ƒ }
 t | | |	 |
 | | ƒ | S(   sÅ  
    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   g  |  D] } | ^ q S(   N(    (   Rº   R7   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   negë  s    (   R–   R¶   R@   R€   R>   R´   Rµ   R    (   R  R  R7   Rú   Rñ   R*  RS  R  R   R  R  (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _int0ooÚ  s    	c           sš   t  | | ƒ \ } ‰ t  | j | ƒ \ } ‰  ‡  ‡ f d †  } t |  | ˆ ˆ  d t ƒt | | j ƒ | | j ƒ | | j ƒ | | j ƒ | j ƒ f S(   s    Absorb ``po`` == x**s into g. c           s   g  |  D] } | ˆ ˆ  ^ q S(   N(    (   Rº   Rh   (   Rg   Rï   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR»   ù  s    R  (	   R–   R¶   R   RP   R    R>   R´   R@   Rµ   (   RC   R¨   R©   R7   Rñ   RJ   R»   (    (   Rg   Rï   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _rewrite_inversionô  s
    c           s  d d l  m ‰ m ‰ m ‰ m ‰  m ‰ m ‰ m ‰ m } m	 } m
 ‰ t d ƒ ˆ j } t | ˆ ƒ \ } } | d k  r— t d ƒ t t ˆ ƒ ˆ ƒ S‡  ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ f	 d †  ‰ ‡  ‡ f d †  ‰
 t t ˆ j ƒ t ˆ j ƒ t ˆ j ƒ t ˆ j ƒ g ƒ \ } } }	 }
 | | |	 } |
 | | } | | d } |
 |	 ‰	 ˆ	 d	 k rkt d	 ƒ d } n ˆ	 d	 k r€d	 } n | } d	 ˆ	 d | ˆ j Œ  | ˆ j Œ  ˆ	 ‰ ˆ j } t d
 | | |	 |
 | | | ˆ	 f ƒ t d | ˆ | f ƒ ˆ j | d k p |	 d	 k o |	 |
 k s1t d ƒ t SxL ˆ j D]A } x8 ˆ j D]- } | | j rK| | k rKt d ƒ t SqKWq;W|	 |
 k rÉt d ƒ ˆ  g  ˆ j D] } ˆ
 | d	 d d | ƒ ^ q£Œ  S‡  ‡ ‡
 f d †  } ‡	 ‡
 ‡ f d †  } ‡	 ‡ ‡ f d †  } ‡	 ‡ ‡ f 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(   s7    Check antecedents for the laplace inversion integral. iÿÿÿÿ(
   RW   t   imR   R   RË   R   Rr   R
   t   nanRô   s#   Checking antecedents for inversion:i    s     Flipping G.c           sˆ  t  | ˆ ƒ \ } } |  | 9}  | | | 9} | | 9} g  } | ˆ ˆ ˆ | ƒ t d ƒ } | ˆ ˆ ˆ | ƒ t d ƒ }	 | r‘ | }
 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(   Ni   i    iÿÿÿÿ(   R–   R   (   RJ   Rg   R…   R%   t   plust   coefft   exponentR   t   wpt   wmt   w(	   R   RË   Rr   Rô   R   R   RV  RW   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   statement_half
  s    

"#	@LBc           s1   ˆ  ˆ |  | | | t  ƒ ˆ |  | | | t ƒ ƒ S(   sW    Provide a convergence statement for z**a * exp(b*z**c),
             c/f sphinx docs. (   RP   R,   (   RJ   Rg   R…   R%   (   R   R^  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   statement  s    i   i   s9     m=%s, n=%s, p=%s, q=%s, tau=%s, nu=%s, rho=%s, sigma=%ss      epsilon=%s, theta=%s, delta=%ss-     Computation not valid for these parameters.s     Not a valid G function.s$     Using asymptotic Slater expansion.c           s3   ˆ  g  ˆ j  D] } ˆ | d d d |  ƒ ^ q Œ  S(   Ni   i    (   R>   (   R%   RJ   (   R   R©   R_  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   EM  s    c           s   ˆ ˆ ˆ  d ˆ  |  ƒ S(   Ni   (    (   R%   (   R,  R_  R-  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   HP  s    c           s   ˆ ˆ ˆ  d ˆ  |  t  ƒ S(   Ni   (   RP   (   R%   (   R,  R^  R-  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   HpS  s    c           s   ˆ ˆ ˆ  d ˆ  |  t  ƒ S(   Ni   (   R,   (   R%   (   R,  R^  R-  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   HmV  s    (   R‚   RW   RV  R   R   RË   R   Rr   R
   RW  Rô   Rõ   R¶   R–   t   _check_antecedents_inversionR¼   R   R­   R@   R>   R?   RA   R³   R,   R"  R   (   R©   R7   R
   RW  R%   Rñ   Rœ   R•   R2   Rj   Rk   R  Rd   R:  t   epsilonR³   RJ   Rg   R`  Ra  Rb  Rc  R   (    (   R   RË   Rr   Rô   R   R   R©   RV  RW   R,  R_  R^  R-  R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyRd  ÿ  sp    F
	
'H
	,	 +

	
3?)?I*,2//A?Ac      	   C  s`   t  |  j | ƒ \ } } t t |  j |  j |  j |  j | | | ƒ | ƒ \ } }  | | |  S(   sO   
    Compute the laplace inversion integral, assuming the formula applies.
    (   R–   R¶   R½   R    R>   R´   R@   Rµ   (   R©   R7   Rh   Rg   RJ   R¸   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _int_inversionx  s    <c   &        sD  d d l  m } m } m ‰ m } m } t sA i  a t t ƒ n  t |  t	 ƒ rd d l  m
 } | |  j | ƒ j | ƒ \ } }	 t |	 ƒ d k r— d S|	 d }	 |	 j rÍ |	 j | k sÆ |	 j j rÝ d Sn |	 | k rÝ d Sd d t	 |  j |  j |  j |  j | |	 ƒ f g t f S|  }
 |  j | t ƒ }  t |  t ƒ } | t k rtt | } x| D]\ } } } } |  j | d t ƒ} | rYi  } x< | j ƒ  D]. \ } } | | | d t ƒd t ƒ| | <q™W| } t | t ƒ sò| j | ƒ } n  | t k rqYn  t | t t f ƒ s1| | j | ƒ ƒ } n  t  | ƒ t k rIqYn  t | t! ƒ sg| | ƒ } n  g  } xê | D]â \ } } t" | | j | ƒ j t | ƒ d t ƒ| ƒ } y | j | ƒ j t | ƒ } Wn t# k
 råqtn X| | | f Œ  j$ ˆ | ˆ ƒ rqtn  t	 | j | j | j | j | | j d t ƒƒ } | j% | | f ƒ qtW| rm| | f SqYqYWn  | s~d St& d	 ƒ d d
 l' m( } m) ‰ m* } m+ ‰  d d l  m ‰ m, } m } m- ‰ m. ‰ ‡  ‡ ‡ ‡ f d †  } |
 }  t/ d d |  ƒ } ‡ f d †  } yF | |  | | d | d t d t ƒ\ } }  }! | | | | |  ƒ } Wn | k
 rpd } n X| d k r,t0 d d ƒ }" |" |  j1 k r,t2 |  | ƒ r,yb | |  j | |" | ƒ | | d | d t d t ƒ\ } }  }! | | | | |  ƒ j |" d ƒ } Wq)| k
 r%d } q)Xq,n  | d k sM| j$ ˆ | | ƒ r[t& d ƒ d St3 j4 | ƒ }# g  } xº |# D]² }  |  j | ƒ \ }$ }	 t |	 ƒ d k r³t5 d ƒ ‚ n  |	 d } t" | j | ƒ \ }" }% | |$ d t	 | j | j | j | j | | |" d t ƒd t ƒ| |% ƒ f g 7} qwWt& d | ƒ | t f S(   sH  
    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.
    iÿÿÿÿ(   R¦   RL   R   t   zoot   Tuple(   t   factori   i    t   oldt   liftt   exponents_onlys)   Trying recursive Mellin transform method.(   t   mellin_transformt   inverse_mellin_transformt   IntegralTransformErrort   MellinTransformStripError(   R   RW  Rg  t   simplifyt   cancelc      	     si   y# ˆ |  | | | d t  d t  ƒSWn? ˆ  k
 rd ˆ ˆ ˆ t |  ƒ ƒ ƒ | | | d t  d t  ƒSXd S(   sÔ    Calling simplify() all the time is slow and not helpful, since
            most of the time it only factors things in a way that has to be
            un-done anyway. But sometimes it can remove apparent poles. t
   as_meijergt   needevalN(   RP   R   (   t   FRï   R7   t   strip(   Rp  Rr  Rn  Rq  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   my_imtÙ  s    !Rï   s   rewrite-singlec           sœ   d d l  m } m } t |  | d t ƒ} | d  k	 r† | \ } } t | | d d ƒƒ } t | | f | |  | d ˆ  f ƒ t f ƒ S| |  | d ˆ  f ƒ S(   Niÿÿÿÿ(   t   IntegralR   t   only_doublet   rewritet   nonrepsmalli    (   R‚   Rx  R   t   _meijerint_definite_4RP   R®   t   _my_unpolarifyR   (   R*   R7   Rx  R   Rb   R0   RD   (   R   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   my_integratoré  s    t
   integratorRq  Rt  RJ   s"   Recursive Mellin transform failed.s   Unexpected form...s"   Recursive Mellin transform worked:N(6   R‚   R¦   RL   R   Rg  Rh  t   _lookup_tableR†   R    R    Ri  R¶   R‘   R­   R®   R’   R“   R   R  R>   R´   R@   Rµ   RP   Rl   R%   R;   R¡   t   itemsRè   R,   R   Rê   R€   R–   t
   ValueErrorR/   R<   Rõ   t   sympy.integrals.transformsRm  Rn  Ro  Rp  RW  Rq  Rr  RÅ   RÀ   Rˆ   RÉ   R
   R§   t   NotImplementedError(&   R*   R7   t	   recursiveR¦   RL   Rg  Rh  Ri  RY  R•   t   f_Rh   Rº   R=   t   termsRD   RE   Rl   t   subs_RÝ   RÞ   R0   RC   R©   R  Rm  Ro  RW  Rw  Rï   R~  Ru  Rv  Rñ   RJ   R.   R…   Rg   (    (   Rp  Rr  Rn  R   Rq  s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _rewrite_singleˆ  sÀ    (!
	8
!#
"(	
%!

$c         C  sL   t  |  | ƒ \ } } } t | | | ƒ } | rH | | | d | d f Sd S(   sö   
    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.
    i    i   N(   Rª   R‰  (   R*   R7   R…  RC   R¨   R©   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   _rewrite1  s    c           s0  t  |  ˆ  ƒ \ } } } t ‡  f d †  t | ƒ Dƒ ƒ r> d St | ƒ } | sT d St t | ‡  f d †  ‡  f d †  ‡  f d †  g ƒ ƒ } xœ t t g D]Ž } x… | D]} \ } } t	 | ˆ  | ƒ }	 t	 | ˆ  | ƒ }
 |	 r§ |
 r§ t
 |	 d |
 d ƒ } | t k r$| | |	 d |
 d | f Sq§ q§ Wqš Wd S(   s  
    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  | ˆ  t ƒ d  k Vq d  S(   N(   R‰  R,   R®   (   R(   R”   (   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pys	   <genexpr>/  s    c           s3   t  t t |  d ˆ  ƒ ƒ t t |  d ˆ  ƒ ƒ ƒ S(   Ni    i   (   t   maxR­   Rš   (   Rj   (   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR8   5  R9   c           s3   t  t t |  d ˆ  ƒ ƒ t t |  d ˆ  ƒ ƒ ƒ S(   Ni    i   (   R‹  R­   Rž   (   Rj   (   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR8   6  R9   c           s3   t  t t |  d ˆ  ƒ ƒ t t |  d ˆ  ƒ ƒ ƒ S(   Ni    i   (   R‹  R­   R¥   (   Rj   (   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR8   7  s   i   i    N(   Rª   RÈ   R¬   R®   R°   R€   R"   R,   RP   R‰  R   (   R*   R7   RC   R¨   R©   Rº   R…  t   fac1t   fac2R  R  RD   (    (   R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt	   _rewrite2&  s$    "	c         C  sE  d d l  m } m } g  } x— t t |  | ƒ t d ƒ h Bd t ƒD]m } t |  j | | | ƒ | ƒ } | sv qE n  | j | | | ƒ } t	 | | | ƒ r® | j
 | ƒ qE | SqE W|  j t ƒ r+t d ƒ t t |  ƒ | ƒ } | r+t | ƒ t k	 rt t | ƒ | j t ƒ ƒ S| j | ƒ q+n  | rAt t | ƒ ƒ Sd S(   s#  
    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)
    iÿÿÿÿ(   t   hyperR    i    t   keys*   Try rewriting hyperbolics in terms of exp.N(   R‚   R  R    t   sortedR¥   R   R$   t   _meijerint_indefinite_1Rl   R'   R<   R/   R   Rõ   t   meijerint_indefiniteR   RŠ   R€   R   R   R   R   t   extendt   nextR"   (   R*   R7   R  R    t   resultsRJ   R0   t   rv(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR“  D  s(    /
c           s	  d d l  m } m } m } m } t d |  d ˆ ƒ t |  ˆ ƒ } | d k rT d S| \ } } }	 }
 t d | ƒ t d ƒ } xÕ|	 D]Í\ } } } t	 | j
 ˆ ƒ \ } } t	 | ˆ ƒ \ } } | | 7} | | | | d | | } | d | d ‰  t d d	 t d ƒ ƒ } ‡  f d
 †  } t d „  | | j ƒ Dƒ ƒ rt | | j ƒ | | j ƒ d g | | j ƒ d g | | j ƒ | ƒ } nJ t | | j ƒ d g | | j ƒ | | j ƒ | | j ƒ d g | ƒ } d } | d k  s
|  j ˆ d ƒ j | | ƒ rd } n  t | j | | ˆ | ƒ d | ƒ} | t | | d t ƒ7} q† W‡ f d †  } | | ƒ } | j rÏg  } x< | j D]1 \ } }
 t | | ƒ ƒ } | | |
 f g 7} q‹Wt | Œ  } n t | | ƒ ƒ } t | t |
 ƒ f | |  ˆ ƒ t f ƒ S(   s0    Helper that does not attempt any substitution. iÿÿÿÿ(   Rx  R   RW  Rg  s,   Trying to compute the indefinite integral oft   wrts    could rewrite:i    i   Rh   s   meijerint-indefinitec           s   g  |  D] } | ˆ  d ^ q S(   Ni   (    (   Rj   RJ   (   R:  (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR»   ‰  s    c         s  s*   |  ]  } | j  o! | d  k t k Vq d S(   i    N(   R"  RP   (   R(   Rg   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pys	   <genexpr>‹  s    t   placeR  c           sB   d d l  m } t | |  ƒ d t ƒ}  t j |  j ˆ  ƒ d ƒ S(   sž  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
        iÿÿÿÿ(   Rr  t   deepi   (   R‚   Rr  R   R,   R
   t
   _from_argst   as_coeff_add(   R0   Rr  (   R7   (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _cleanœ  s    N(   R‚   Rx  R   RW  Rg  Rõ   RŠ  R®   R   R–   R¶   RÅ   RÈ   R@   R    R>   R´   Rµ   Rl   R/   R   R   RP   R&   R.   R}  R   (   R*   R7   Rx  R   RW  Rg  R«   RC   R¨   t   glRD   R0   R¸   Rï   R©   RJ   Rg   Rñ   R…   t   fac_Rh   R»   Rb   R™  R  Rç   R”   (    (   R:  R7   s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR’  i  sH    "

KG*	&	c         C  sQ  d d l  m } m } m } m } m } m }	 t d |  d | | | f ƒ |  j | ƒ rh t d ƒ d S|  j |	 ƒ r… t d ƒ d S|  | | | f \ }
 } } } t
 d ƒ } |  j | | ƒ }  | } | | k rà t j t f Sg  } | t k r!| t k r!t |  j | | ƒ | | | ƒ S| t k r}t d ƒ t |  | ƒ } t d	 | ƒ xLt | d
 t d t ƒt d ƒ g D]ü } t d | ƒ | j s¦t d ƒ qzn  t |  j | | | ƒ | ƒ } | d k rát d ƒ qzn  t |  j | | | ƒ | ƒ } | d k rt d ƒ qzn  | \ } } | \ } } t | | | ƒ ƒ } | t k ret d ƒ qzn  | | } | | f SWn&| t k r±t |  | | t ƒ } | d | d f S| | f d t f k rt |  | ƒ } | r£t | d t ƒ r| j | ƒ q| Sq£n˜| t k r¼x¢ t |  | ƒ D]Ž } | | d k t k r't d | ƒ t |  j | | | ƒ t | | | ƒ | ƒ } | rµt | d t ƒ r«| j | ƒ q²| Sqµq'q'Wn  |  j | | | ƒ }  | | } d } | t k rG| | | | ƒ ƒ } t | ƒ } |  j | | | ƒ }  |  t | | ƒ | 9}  t } n  t d | | ƒ t d |  ƒ t |  | ƒ } | r£t | d t ƒ rœ| j | ƒ q£| Sn  |
 j t ƒ r7t d ƒ t t |
 ƒ | | | ƒ } | r7t | ƒ t  k	 r$t! t" | d ƒ | d j# | ƒ ƒ f | d } | S| j$ | ƒ q7n  | rMt% t& | ƒ ƒ Sd S(   sà  
    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.
    iÿÿÿÿ(   RB   R   Rr   R   R   t   SingularityFunctiont   Integratings   wrt %s from %s to %s.s+   Integrand has DiracDelta terms - giving up.s5   Integrand has Singularity Function terms - giving up.R7   s     Integrating -oo to +oo.s     Sensible splitting points:R  t   reversei    s     Trying to split ats     Non-real splitting point.s'     But could not compute first integral.s(     But could not compute second integral.s)     But combined condition is always false.i   s   Trying x -> x + %ss   Changed limits tos   Changed function tos*   Try rewriting hyperbolics in terms of exp.N('   R‚   RB   R   Rr   R   R   R   Rõ   R/   R®   R   Rl   R   t   ZeroRP   R   t   meijerint_definiteR¥   R‘  R$   t   is_realt   _meijerint_definite_2RØ   R,   R'   R    R<   R   Rƒ   R   R   RŠ   R€   R   R   R   R”  R•  R"   (   R*   R7   RJ   Rg   RB   R   Rr   R   R   R   R†  t   x_t   a_t   b_RÄ   R–  R¤   R…   t   res1t   res2t   cond1t   cond2RD   R0   t   splitR<  R—  (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR¤  Á  s°    .

"
,	






	
1c   	      C  sf  d d l  m } d d l m } |  d f g } | d d } | h } t | ƒ } | | k r | | d f g 7} | j | ƒ n  t | ƒ } | | k r¼ | | d f g 7} | j | ƒ n  | j | t ƒ rt | | ƒ ƒ } | | k r| | d f g 7} | j | ƒ qn  | j t	 t
 ƒ rbt | ƒ } | | k rb| | d	 f g 7} | j | ƒ qbn  | S(
   s6    Try to guess sensible rewritings for integrand f(x). iÿÿÿÿ(   t   expand_trig(   t   TrigonometricFunctions   original integrandi    R   R   s   expand_trig, expand_muls   trig power reduction(   R‚   R¯  t(   sympy.functions.elementary.trigonometricR°  R   RG   R   R/   R   R   R   R   (	   R*   R7   R¯  R°  R0   RÓ   t   sawt   expandedt   reduced(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   _guess_expansionL  s0    	c         C  s–   t  d d |  d t ƒ} |  j | | ƒ }  | } |  d k rL t d ƒ t f SxC t |  | ƒ D]2 \ } } t d | ƒ t | | ƒ } | r\ | Sq\ Wd S(   s  
    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.
    R7   s   meijerint-definite2t   positivei    t   TryingN(   RÅ   RP   Rl   R   Rµ  Rõ   t   _meijerint_definite_3(   R*   R7   t   dummyR©   t   explanationR0   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR¦  m  s    c         C  sã   t  |  | ƒ } | r) | d t k r) | S|  j rß t d ƒ g  |  j D] } t  | | ƒ ^ qF } t d „  | Dƒ ƒ rß g  } t d ƒ } x+ | D]# \ } } | | 7} | | g 7} q Wt | Œ  } | t k rÜ | | f Sqß n  d S(   s²   
    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.
    i   s#   Expanding and evaluating all terms.c         s  s   |  ] } | d  k	 Vq d  S(   N(   R®   (   R(   Rb   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pys	   <genexpr>˜  s    i    N(   R|  R,   t   is_AddRõ   R.   R-   R   R   (   R*   R7   R0   R©   t   ressR   Rb   R…   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR¸  ‹  s    	
%
c         C  s    d d l  m } t | |  ƒ ƒ S(   Niÿÿÿÿ(   RL   (   R‚   RL   Rê   (   R*   RL   (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR}  £  s    c      
   C  sù  t  d |  ƒ | sEt |  | d t ƒ} | d	 k	 rE| \ } } } } t  d | | | ƒ t d ƒ } x | D]‡ \ }	 }
 }  |	 d k r ql n  t | |	 | | |
 |  | ƒ \ }	 }  | |	 t |  | ƒ 7} t | t |  | ƒ ƒ } | t k rl Pql ql Wt	 | ƒ } | t k rt  d ƒ qBt  d | ƒ t	 t
 | ƒ ƒ | f SqEn  t |  | ƒ } | d	 k	 rõx’t t g D]} | \ } } } } } t  d | | | | ƒ t d ƒ } xå | D]Ý \ } } } xÊ | D]¿ \ } } } t | | | | | | | | | | | ƒ } | d	 k rt  d ƒ d	 S| \ }	 } } t  d
 |	 | | ƒ t | t | | | ƒ ƒ } | t k rlPn  | |	 t | | | ƒ 7} qÇWq±Pq±Wt	 | ƒ } | t k r»t  d | ƒ qmt  d | ƒ | rØ| | f St	 t
 | ƒ ƒ | f SqmWn  d	 S(   s`  
    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.
    R¡  R…  s#   Could rewrite as single G function:i    s   But cond is always False.s&   Result before branch substitutions is:s!   Could rewrite as two G functions:s   Non-rational exponents.Ns   Saxena subst for yielded:s&   But cond is always False (full_pb=%s).(   Rõ   RŠ  R,   R®   R   Rò   R  R   R÷   R}  R   RŽ  RP   R!  RR  RT  (   R*   R7   Ry  R«   RC   R¨   R©   RD   R0   R¸   Rï   Rí   R  R  R  t   s1t   f1R  t   s2t   f2Rb   t   f1_t   f2_(    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyR|  ¨  s`    '

c          C  sì  d d l  m } m } m } m } m } m } m }	 m }
 |  } | } t	 d d t
 ƒ} |  j | | ƒ }  t d |  ƒ t |  | ƒ s” t d ƒ d St j } |  j r¸ t |  j ƒ } n! t |  | ƒ rÓ |  g } n d } | r~g  } g  } xu| rb| j ƒ  } t | | ƒ r| | ƒ } | j r7| | j 7} qî n  y  t | j d | ƒ \ } } Wn t k
 rpd } n X| d k r| j | ƒ q_| j | ƒ qî | j rR| | ƒ } | j rÎ| | j 7} qî n  | | j j k rBy t | j | ƒ \ } } Wn t k
 rd } n X| d k rB| j | | | j ƒ ƒ qBn  | j | ƒ qî | j | ƒ qî W| | Œ  } |	 | Œ  }  n  | |  j k r"t d	 |  | ƒ d d
 l  m } m } | | | ƒ d ƒ } | t k rât d ƒ d S|  t | | ƒ } t d | | ƒ t  | j | | ƒ | f ƒ St! |  | ƒ } | d k	 rè| \ } } } } t d | | | ƒ t d ƒ } x€ | D]x \ } } }  t" | | | | | |  | ƒ \ } }  | | t# |  | | ƒ 7} t$ | t% |  | ƒ ƒ } | t k ruPququWt& | ƒ } | t k rt d ƒ qèt d | ƒ t& t' | ƒ ƒ } | j( |
 ƒ sW| |
 | ƒ 9} n  | j | | | ƒ } t | t) ƒ s•| j | | | ƒ } n  d d l  m* } t  | j | | ƒ | f | | j | | ƒ | | d ƒ t
 f ƒ Sn  d S(   sç  
    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)
    iÿÿÿÿ(   Rr   Rx  R   R   R]   R
   R   R   Rh   R  s   Laplace-invertings   But expression is not analytic.i    i   s.   Expression consists of constant and exp shift:(   RË   RV  s3   but shift is nonreal, cannot be a Laplace transforms1   Result is a delta function, possibly conditional:s#   Could rewrite as single G function:s   But cond is always False.s"   Result before branch substitution:(   t   InverseLaplaceTransformN(+   R‚   Rr   Rx  R   R   R]   R
   R   R   R   RP   Rl   Rõ   RÉ   R®   R   R£  t   is_MulR€   R.   R    t   popR–   RŽ   R<   R’   R“   Rˆ   RË   RV  R,   R   R   RŠ  RU  Rf  R   Rd  R}  R   R/   Rè   RÃ  (    R*   R7   Rh   Rr   Rx  R   R   R]   R
   R   R   R†  t   t_t   shiftR.   Rç   t   exponentialsRB   Rã   RJ   Rg   RË   RV  RD   R0   R«   RC   R¨   R©   R¸   Rï   RÃ  (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   meijerint_inversionì  s¤    :
				 
		
 
'N(o   R   t
   __future__R    R   t
   sympy.coreR   R   R   R   t   sympy.core.exprtoolsR   t   sympy.core.functionR   R   R	   t   sympy.core.addR
   t   sympy.core.mulR   t   sympy.core.compatibilityR   t   sympy.core.cacheR   t   sympy.core.symbolR   R   t   sympy.simplifyR   R   R   t   sympy.simplify.fuR   R×   R   R   R   t'   sympy.functions.special.delta_functionsR   R   t&   sympy.functions.elementary.exponentialR   t$   sympy.functions.elementary.piecewiseR   R   t%   sympy.functions.elementary.hyperbolicR   R   R±  R   R   t   sympy.functions.special.hyperR    t   sympy.utilities.iterablesR!   R"   t   sympy.utilities.miscR#   Rõ   t   sympy.utilitiesR$   R%   R'   R†   t   sympy.utilities.timeutilsR‡   t   timeitR;   R‚  RŽ   R–   Rš   Rž   R¥   Rª   R¬   R°   R¹   R¼   R½   RÆ   RÅ   RÀ   RÉ   RØ   Rê   R,   Rî   Rò   R÷   R  R!  RR  RT  RU  Rd  Rf  R®   R€  RP   R‰  RŠ  RŽ  R“  R’  R¤  Rµ  R¦  R¸  R}  R|  RÉ  (    (    (    s8   lib/python2.7/site-packages/sympy/integrals/meijerint.pyt   <module>   sŽ   "			Ú					!	%										e		u	C	ÿ 1			y	Ž		%	X‹	!			C