U
    ZÊ¹jœ§  ã                   @   sÀ  d dl 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mZ d dlmZmZmZmZ d dlmZ d dlmZ d d	lmZmZmZ d d
lmZmZ d dl m!Z!m"Z" d dl#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/m0Z0m1Z1m2Z2 d dl3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9 dd„ Z:G dd„ de
ƒZ;G dd„ de
ƒZ<G dd„ de
ƒZ=G dd„ de
ƒZ>G dd„ de
ƒZ?G d d!„ d!e
ƒZ@G d"d#„ d#e
ƒZAG d$d%„ d%e
ƒZBd&S )'é    )Úprod)ÚAddÚSÚDummyÚexpand_func)ÚExpr)ÚFunctionÚArgumentIndexErrorÚ	PoleError)Ú	fuzzy_andÚ	fuzzy_not)ÚRationalÚpiÚooÚI©ÚPow©Úzeta)ÚerfÚerfcÚEi)ÚreÚ
unpolarify)ÚexpÚlog)ÚceilingÚfloor)Úsqrt)ÚsinÚcosÚcot)Ú	bernoulliÚharmonic)Ú	factorialÚrfÚRisingFactorial)Úas_int)ÚmpÚworkprec)Úprec_to_dpsc                 C   s.   zt | dd� W dS  tk
r(   Y dS X d S )NF)ÚstrictT)r'   Ú
ValueError©Ún© r/   úf/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/functions/special/gamma_functions.pyÚintlike   s
    r1   c                       s€   e Zd ZdZdZejfZddd„Ze	dd„ ƒZ
dd	„ Zd
d„ Zdd„ Zdd„ Zddd„Zdd„ Zd‡ fdd„	Zddd„Z‡  ZS )Úgammaañ  
    The gamma function

    .. math::
        \Gamma(x) := \int^{\infty}_{0} t^{x-1} e^{-t} \mathrm{d}t.

    Explanation
    ===========

    The ``gamma`` function implements the function which passes through the
    values of the factorial function (i.e., $\Gamma(n) = (n - 1)!$ when n is
    an integer). More generally, $\Gamma(z)$ is defined in the whole complex
    plane except at the negative integers where there are simple poles.

    Examples
    ========

    >>> from sympy import S, I, pi, gamma
    >>> from sympy.abc import x

    Several special values are known:

    >>> gamma(1)
    1
    >>> gamma(4)
    6
    >>> gamma(S(3)/2)
    sqrt(pi)/2

    The ``gamma`` function obeys the mirror symmetry:

    >>> from sympy import conjugate
    >>> conjugate(gamma(x))
    gamma(conjugate(x))

    Differentiation with respect to $x$ is supported:

    >>> from sympy import diff
    >>> diff(gamma(x), x)
    gamma(x)*polygamma(0, x)

    Series expansion is also supported:

    >>> from sympy import series
    >>> series(gamma(x), x, 0, 3)
    1/x - EulerGamma + x*(EulerGamma**2/2 + pi**2/12) + x**2*(-EulerGamma*pi**2/12 - zeta(3)/3 - EulerGamma**3/6) + O(x**3)

    We can numerically evaluate the ``gamma`` function to arbitrary precision
    on the whole complex plane:

    >>> gamma(pi).evalf(40)
    2.288037795340032417959588909060233922890
    >>> gamma(1+I).evalf(20)
    0.49801566811835604271 - 0.15494982830181068512*I

    See Also
    ========

    lowergamma: Lower incomplete gamma function.
    uppergamma: Upper incomplete gamma function.
    polygamma: Polygamma function.
    loggamma: Log Gamma function.
    digamma: Digamma function.
    trigamma: Trigamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Gamma_function
    .. [2] https://dlmf.nist.gov/5
    .. [3] https://mathworld.wolfram.com/GammaFunction.html
    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma/

    Té   c                 C   s6   |dkr(|   | jd ¡td| jd ƒ S t| |ƒ‚d S ©Nr3   r   )ÚfuncÚargsÚ	polygammar	   ©ÚselfÚargindexr/   r/   r0   Úfdiffr   s     zgamma.fdiffc                 C   sè   |j rä|tjkrtjS |tkr"tS t|ƒrD|jr<t|d ƒS tjS n |jrä|j	dkrät
|jƒ|j	 }|jrx|tj }}n&|d  }}|d@ dkr˜tj}ntj}|ttdd| dƒƒ9 }|jrÐ|ttƒ d|  S d| ttƒ | S d S )Nr3   é   r   é   )Ú	is_Numberr   ÚNaNr   r1   Úis_positiver$   ÚComplexInfinityÚis_RationalÚqÚabsÚpÚOneÚNegativeOner   Úranger   r   )ÚclsÚargr.   ÚkÚcoeffr/   r/   r0   Úevalx   s,    

z
gamma.evalc           	      K   sÐ   | j d }|jrft|jƒ|jkrftdƒ}|j|j }|j||j  }|  || ¡ ¡  |t	||jƒ¡S |j
rÄ| ¡ \}}|r |jdkr t|ƒ}|| f| }|}|j|ddiŽ}|  |¡t||ƒ S | j| j Ž S )Nr   Úxr3   ZreevalF)r6   rB   rD   rE   rC   r   r5   Ú_eval_expand_funcÚsubsr   Úis_AddZas_coeff_addr   Z_new_rawargsr&   )	r9   ÚhintsrJ   rN   r.   rE   rL   ÚtailZintpartr/   r/   r0   rO   ™   s     
"zgamma._eval_expand_funcc                 C   s   |   | jd  ¡ ¡S ©Nr   )r5   r6   Ú	conjugate©r9   r/   r/   r0   Ú_eval_conjugate­   s    zgamma._eval_conjugatec                 C   sB   | j d }|jr|jrdS t|ƒr.|dkr.dS |js:|jr>dS d S )Nr   FT)r6   Úis_nonpositiveÚ
is_integerr1   r@   Úis_noninteger©r9   rN   r/   r/   r0   Ú_eval_is_real°   s    
zgamma._eval_is_realc                 C   s(   | j d }|jrdS |jr$t|ƒjS d S )Nr   T)r6   r@   rZ   r   Úis_evenr[   r/   r/   r0   Ú_eval_is_positive¹   s
    
zgamma._eval_is_positiveNc                 K   s   t t|ƒƒS ©N)r   Úloggamma)r9   ÚzZlimitvarÚkwargsr/   r/   r0   Ú_eval_rewrite_as_tractableÀ   s    z gamma._eval_rewrite_as_tractablec                 K   s   t |d ƒS ©Nr3   ©r$   ©r9   ra   rb   r/   r/   r0   Ú_eval_rewrite_as_factorialÃ   s    z gamma._eval_rewrite_as_factorialr   c                    sl   | j d  |d¡}|jr |dks0tƒ  |||¡S | j d | }|  |d ¡t| j d | d ƒ  |||¡S ©Nr   r3   )r6   ÚlimitÚ
is_IntegerÚsuperÚ_eval_nseriesr5   r%   )r9   rN   r.   ÚlogxÚcdirÚx0Út©Ú	__class__r/   r0   rl   Æ   s
    zgamma._eval_nseriesc                 C   sl   | j d }| |d¡}|jrR|jrR| }tj| |  |d ¡ }|||  |¡ S |jsb|  |¡S t	ƒ ‚d S rh   )
r6   rP   rY   rX   r   rG   r5   Úas_leading_termÚis_infiniter
   )r9   rN   rm   rn   rJ   ro   r.   Úresr/   r/   r0   Ú_eval_as_leading_termÍ   s    

zgamma._eval_as_leading_term)r3   )N)r   )Nr   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú
unbranchedr   rA   Z_singularitiesr;   ÚclassmethodrM   rO   rW   r\   r^   rc   rg   rl   rv   Ú__classcell__r/   r/   rq   r0   r2   "   s   L

 	
r2   c                       sf   e Zd ZdZddd„Zedd„ ƒZdd„ Zd	d
„ Zdd„ Z	‡ fdd„Z
dd„ Zdd„ Zdd„ Z‡  ZS )Ú
lowergammaañ  
    The lower incomplete gamma function.

    Explanation
    ===========

    It can be defined as the meromorphic continuation of

    .. math::
        \gamma(s, x) := \int_0^x t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \Gamma(s, x).

    This can be shown to be the same as

    .. math::
        \gamma(s, x) = \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),

    where ${}_1F_1$ is the (confluent) hypergeometric function.

    Examples
    ========

    >>> from sympy import lowergamma, S
    >>> from sympy.abc import s, x
    >>> lowergamma(s, x)
    lowergamma(s, x)
    >>> lowergamma(3, x)
    -2*(x**2/2 + x + 1)*exp(-x) + 2
    >>> lowergamma(-S(1)/2, x)
    -2*sqrt(pi)*erf(sqrt(x)) - 2*exp(-x)/sqrt(x)

    See Also
    ========

    gamma: Gamma function.
    uppergamma: Upper incomplete gamma function.
    polygamma: Polygamma function.
    loggamma: Log Gamma function.
    digamma: Digamma function.
    trigamma: Trigamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Incomplete_gamma_function#Lower_incomplete_gamma_function
    .. [2] Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6,
           Section 5, Handbook of Mathematical Functions with Formulas, Graphs,
           and Mathematical Tables
    .. [3] https://dlmf.nist.gov/8
    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma2/
    .. [5] https://functions.wolfram.com/GammaBetaErf/Gamma3/

    r<   c                 C   s”   ddl m} |dkr8| j\}}tt|ƒ ƒ||d   S |dkr†| j\}}t|ƒt|ƒ t|ƒt||ƒ  |g ddgdd|gg |ƒ S t	| |ƒ‚d S ©Nr   )Úmeijergr<   r3   )
Úsympy.functions.special.hyperr€   r6   r   r   r2   Údigammar   Ú
uppergammar	   ©r9   r:   r€   Úara   r/   r/   r0   r;     s    

 ÿzlowergamma.fdiffc              	      s  ˆt jkrt jS ˆ ¡ \}}ˆ jrDˆ jrDtˆƒ}|ˆkr´tˆ |ƒS npˆ jrŠˆ jrŠ|dkr´dt t	 | t j
ˆ    tˆ  ƒ tˆ |ƒ S n*|dkr´tdt t	 | ˆ  ƒtˆ |ƒ S ˆ j�rˆ t jkrÖt jtˆ ƒ S ˆ t jkrôttƒttˆƒƒ S ˆ j�sdˆ  j�rˆ d }|j�rœˆ j�rTt|ƒtˆ ƒt|ƒ t‡fdd„tˆ ƒD ƒŽ   S tˆ ƒtt jˆƒttƒ tˆ ƒt‡fdd„tdˆ t j ƒD ƒŽ    S ˆ j�st j
t jˆ   t ttˆƒƒ tdˆ  ƒ tˆ ƒt‡ ‡fdd„tdtddƒˆ  ƒD ƒŽ   S ˆj�rt jS d S )	Nr   r<   r3   c                    s   g | ]}ˆ | t |ƒ ‘qS r/   re   ©Ú.0rK   ©rN   r/   r0   Ú
<listcomp>K  s     z#lowergamma.eval.<locals>.<listcomp>c                    s(   g | ] }ˆ |t j  tt j| ƒ ‘qS r/   )r   ÚHalfr2   r†   rˆ   r/   r0   r‰   M  s     c                    s0   g | ](}ˆ|ˆ  d   t ˆ ƒ t ˆ | ƒ ‘qS ©r3   ©r2   r†   ©r…   rN   r/   r0   r‰   P  s     r=   )r   ÚZeroÚextract_branch_factorrY   r@   r   r~   rX   r   r   rG   r$   r   r>   rF   rŠ   r   r   rj   r   rH   r2   r   Úis_zero)rI   r…   rN   Únxr.   Úbr/   r�   r0   rM   #  s6    
2"

4H^zlowergamma.evalc              	   C   sj   t dd„ | jD ƒƒrb| jd  |¡}| jd  |¡}t|ƒ� t |d|¡}W 5 Q R X t ||¡S | S d S )Nc                 s   s   | ]}|j V  qd S r_   ©Z	is_number©r‡   rN   r/   r/   r0   Ú	<genexpr>V  s     z)lowergamma._eval_evalf.<locals>.<genexpr>r   r3   )Úallr6   Ú
_to_mpmathr)   r(   Úgammaincr   Ú_from_mpmath©r9   Úprecr…   ra   ru   r/   r/   r0   Ú_eval_evalfU  s    
zlowergamma._eval_evalfc                 C   s8   | j d }|tjtjfkr4|  | j d  ¡ | ¡ ¡S d S r4   ©r6   r   rŽ   ÚNegativeInfinityr5   rU   r[   r/   r/   r0   rW   _  s    
zlowergamma._eval_conjugatec                 C   st   | j \}}t| ||¡| ||¡gƒ}|s.|S | ||¡}|jrPt|j|jgƒS | ||¡}t|j|jt|jƒgƒS r_   )	r6   r   Ú_eval_is_meromorphicrP   rY   r@   Ú	is_finiter   r�   )r9   rN   r…   Úsra   Z
args_meromÚz0Ús0r/   r/   r0   rŸ   d  s    

ÿzlowergamma._eval_is_meromorphicc           	         s’   ddl m} | j\‰ ‰|d tkr€ˆ |¡s€ˆˆ  tˆ ƒ }t‡ ‡fdd„t|d ƒD ƒƒ}|ˆˆ  ˆ |   ƒ}|| | S tƒ  	||||¡S )Nr   )ÚOc                 3   s$   | ]}ˆ| t ˆ |d  ƒ V  qdS )r3   N)r%   r†   ©r¡   ra   r/   r0   r•   z  s     z+lowergamma._eval_aseries.<locals>.<genexpr>r3   )
Úsympy.series.orderr¤   r6   r   Úhasr   ÚsumrH   rk   Ú_eval_aseries)	r9   r.   Úargs0rN   rm   r¤   rL   Zsum_exprÚorq   r¥   r0   r©   u  s    
 zlowergamma._eval_aseriesc                 K   s   t |ƒt||ƒ S r_   )r2   rƒ   ©r9   r¡   rN   rb   r/   r/   r0   Ú_eval_rewrite_as_uppergamma  s    z&lowergamma._eval_rewrite_as_uppergammac                 K   s,   ddl m} |jr|jr| S |  t¡ |¡S )Nr   ©Úexpint)Ú'sympy.functions.special.error_functionsr¯   rY   rX   Úrewriterƒ   ©r9   r¡   rN   rb   r¯   r/   r/   r0   Ú_eval_rewrite_as_expint‚  s    z"lowergamma._eval_rewrite_as_expintc                 C   s   | j d }|jrdS d S )Nr3   T)r6   r�   r[   r/   r/   r0   Ú_eval_is_zeroˆ  s    
zlowergamma._eval_is_zero)r<   )rw   rx   ry   rz   r;   r|   rM   rœ   rW   rŸ   r©   r­   r³   r´   r}   r/   r/   rq   r0   r~   Þ   s   7

1

r~   c                   @   sV   e Zd ZdZddd„Zdd„ Zedd„ ƒZd	d
„ Zdd„ Z	dd„ Z
dd„ Zdd„ ZdS )rƒ   aË  
    The upper incomplete gamma function.

    Explanation
    ===========

    It can be defined as the meromorphic continuation of

    .. math::
        \Gamma(s, x) := \int_x^\infty t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \gamma(s, x).

    where $\gamma(s, x)$ is the lower incomplete gamma function,
    :class:`lowergamma`. This can be shown to be the same as

    .. math::
        \Gamma(s, x) = \Gamma(s) - \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),

    where ${}_1F_1$ is the (confluent) hypergeometric function.

    The upper incomplete gamma function is also essentially equivalent to the
    generalized exponential integral:

    .. math::
        \operatorname{E}_{n}(x) = \int_{1}^{\infty}{\frac{e^{-xt}}{t^n} \, dt} = x^{n-1}\Gamma(1-n,x).

    Examples
    ========

    >>> from sympy import uppergamma, S
    >>> from sympy.abc import s, x
    >>> uppergamma(s, x)
    uppergamma(s, x)
    >>> uppergamma(3, x)
    2*(x**2/2 + x + 1)*exp(-x)
    >>> uppergamma(-S(1)/2, x)
    -2*sqrt(pi)*erfc(sqrt(x)) + 2*exp(-x)/sqrt(x)
    >>> uppergamma(-2, x)
    expint(3, x)/x**2

    See Also
    ========

    gamma: Gamma function.
    lowergamma: Lower incomplete gamma function.
    polygamma: Polygamma function.
    loggamma: Log Gamma function.
    digamma: Digamma function.
    trigamma: Trigamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Incomplete_gamma_function#Upper_incomplete_gamma_function
    .. [2] Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6,
           Section 5, Handbook of Mathematical Functions with Formulas, Graphs,
           and Mathematical Tables
    .. [3] https://dlmf.nist.gov/8
    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma2/
    .. [5] https://functions.wolfram.com/GammaBetaErf/Gamma3/
    .. [6] https://en.wikipedia.org/wiki/Exponential_integral#Relation_with_other_functions

    r<   c                 C   s†   ddl m} |dkr:| j\}}tt|ƒ ƒ ||d   S |dkrx| j\}}t||ƒt|ƒ |g ddgdd|gg |ƒ S t| |ƒ‚d S r   )r�   r€   r6   r   r   rƒ   r   r	   r„   r/   r/   r0   r;   Ð  s    

,zuppergamma.fdiffc              	   C   sh   t dd„ | jD ƒƒrd| jd  |¡}| jd  |¡}t|ƒ� t ||tj¡}W 5 Q R X t ||¡S | S )Nc                 s   s   | ]}|j V  qd S r_   r“   r”   r/   r/   r0   r•   Ü  s     z)uppergamma._eval_evalf.<locals>.<genexpr>r   r3   )	r–   r6   r—   r)   r(   r˜   Úinfr   r™   rš   r/   r/   r0   rœ   Û  s    
zuppergamma._eval_evalfc                    sð  ddl m} ˆjrHˆtjkr"tjS ˆtkr0tjS ˆjrHtˆ ƒj	rHt
ˆ ƒS ˆ ¡ \}}ˆ jr|ˆ j	r|tˆƒ}ˆ|krztˆ |ƒS n–ˆ jrÂˆ jrÂ|dkrÀdt t | tjˆ    tˆ  ƒ tˆ |ƒ S nP|dk�rt
ˆ ƒdtdt t | ˆ  ƒ  tdt t | ˆ  ƒtˆ |ƒ  S ˆ j�r´ˆ tjk�r:ˆj	�r:tˆ ƒ S ˆ tjk�rPtˆ ƒS ˆ tjk�rpttƒttˆƒƒ S ˆ j�s„dˆ  j�r´ˆ d }|j	�r(ˆ j�rÈtˆ ƒt|ƒ t‡fdd„tˆ ƒD ƒŽ  S t
ˆ ƒttˆƒƒ tjˆ tdƒd   tˆ ƒ tˆƒ t‡ ‡fd	d„tˆ tj ƒD ƒŽ   S n$|j�rL|| ˆƒtˆƒ|d   S ˆ j�s´tjtjˆ   t ttˆƒƒ t
dˆ  ƒ ˆˆ  tˆ ƒ t‡ ‡fd
d„ttjˆ  ƒD ƒŽ   S ˆ j�rÐˆj	�rÐtˆ ƒ S ˆj�rìtˆ ƒj	�rìt
ˆ ƒS d S )Nr   r®   éþÿÿÿr3   r<   c                    s   g | ]}ˆ | t |ƒ ‘qS r/   re   r†   ©ra   r/   r0   r‰     s   ÿz#uppergamma.eval.<locals>.<listcomp>r=   c                    s2   g | ]*}t tj | ƒˆ |  t d ˆ  ƒ ‘qS r‹   )r2   r   rŠ   r†   ©r…   ra   r/   r0   r‰     s   ÿc                    s,   g | ]$}ˆ| t ˆ ƒ t ˆ | d  ƒ ‘qS r‹   rŒ   r†   r¸   r/   r0   r‰     s   ÿ)r°   r¯   r>   r   r?   r   rŽ   r�   r   r@   r2   r�   rY   r   rƒ   rX   r   r   rG   r$   r   r   rF   rŠ   r   r   rj   r   rH   )rI   r…   ra   r¯   r‘   r.   r’   r/   r¸   r0   rM   ä  sh    

2
F
ÿ
&ÿÿÿ*ÿÿzuppergamma.evalc                 C   s8   | j d }|tjtjfkr4|  | j d  ¡ | ¡ ¡S d S r4   r�   ©r9   ra   r/   r/   r0   rW     s    
zuppergamma._eval_conjugatec                 C   s   t  | ||¡S r_   )r~   rŸ   )r9   rN   r…   r/   r/   r0   rŸ   "  s    zuppergamma._eval_is_meromorphicc                 K   s   t |ƒt||ƒ S r_   )r2   r~   r¬   r/   r/   r0   Ú_eval_rewrite_as_lowergamma%  s    z&uppergamma._eval_rewrite_as_lowergammac                 K   s   t t|ƒƒt||ƒ S r_   )r   r`   r~   r¬   r/   r/   r0   rc   (  s    z%uppergamma._eval_rewrite_as_tractablec                 K   s"   ddl m} |d| |ƒ||  S )Nr   r®   r3   )r°   r¯   r²   r/   r/   r0   r³   +  s    z"uppergamma._eval_rewrite_as_expintN)r<   )rw   rx   ry   rz   r;   rœ   r|   rM   rW   rŸ   rº   rc   r³   r/   r/   r/   r0   rƒ   Ž  s   A
	
8rƒ   c                       s€   e Zd ZdZedd„ ƒZdd„ Zdd„ Zdd	„ Zd
d„ Z	dd„ Z
dd„ Zdd„ Zddd„Zddd„Z‡ fdd„Zdd„ Z‡  ZS )r7   a¯  
    The function ``polygamma(n, z)`` returns ``log(gamma(z)).diff(n + 1)``.

    Explanation
    ===========

    It is a meromorphic function on $\mathbb{C}$ and defined as the $(n+1)$-th
    derivative of the logarithm of the gamma function:

    .. math::
        \psi^{(n)} (z) := \frac{\mathrm{d}^{n+1}}{\mathrm{d} z^{n+1}} \log\Gamma(z).

    For `n` not a nonnegative integer the generalization by Espinosa and Moll [5]_
    is used:

    .. math:: \psi(s,z) = \frac{\zeta'(s+1, z) + (\gamma + \psi(-s)) \zeta(s+1, z)}
        {\Gamma(-s)}

    Examples
    ========

    Several special values are known:

    >>> from sympy import S, polygamma
    >>> polygamma(0, 1)
    -EulerGamma
    >>> polygamma(0, 1/S(2))
    -2*log(2) - EulerGamma
    >>> polygamma(0, 1/S(3))
    -log(3) - sqrt(3)*pi/6 - EulerGamma - log(sqrt(3))
    >>> polygamma(0, 1/S(4))
    -pi/2 - log(4) - log(2) - EulerGamma
    >>> polygamma(0, 2)
    1 - EulerGamma
    >>> polygamma(0, 23)
    19093197/5173168 - EulerGamma

    >>> from sympy import oo, I
    >>> polygamma(0, oo)
    oo
    >>> polygamma(0, -oo)
    oo
    >>> polygamma(0, I*oo)
    oo
    >>> polygamma(0, -I*oo)
    oo

    Differentiation with respect to $x$ is supported:

    >>> from sympy import Symbol, diff
    >>> x = Symbol("x")
    >>> diff(polygamma(0, x), x)
    polygamma(1, x)
    >>> diff(polygamma(0, x), x, 2)
    polygamma(2, x)
    >>> diff(polygamma(0, x), x, 3)
    polygamma(3, x)
    >>> diff(polygamma(1, x), x)
    polygamma(2, x)
    >>> diff(polygamma(1, x), x, 2)
    polygamma(3, x)
    >>> diff(polygamma(2, x), x)
    polygamma(3, x)
    >>> diff(polygamma(2, x), x, 2)
    polygamma(4, x)

    >>> n = Symbol("n")
    >>> diff(polygamma(n, x), x)
    polygamma(n + 1, x)
    >>> diff(polygamma(n, x), x, 2)
    polygamma(n + 2, x)

    We can rewrite ``polygamma`` functions in terms of harmonic numbers:

    >>> from sympy import harmonic
    >>> polygamma(0, x).rewrite(harmonic)
    harmonic(x - 1) - EulerGamma
    >>> polygamma(2, x).rewrite(harmonic)
    2*harmonic(x - 1, 3) - 2*zeta(3)
    >>> ni = Symbol("n", integer=True)
    >>> polygamma(ni, x).rewrite(harmonic)
    (-1)**(n + 1)*(-harmonic(x - 1, n + 1) + zeta(n + 1))*factorial(n)

    See Also
    ========

    gamma: Gamma function.
    lowergamma: Lower incomplete gamma function.
    uppergamma: Upper incomplete gamma function.
    loggamma: Log Gamma function.
    digamma: Digamma function.
    trigamma: Trigamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Polygamma_function
    .. [2] https://mathworld.wolfram.com/PolygammaFunction.html
    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma/
    .. [4] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
    .. [5] O. Espinosa and V. Moll, "A generalized polygamma function",
           *Integral Transforms and Special Functions* (2004), 101-115.

    c                 C   sp  |t jks|t jkrt jS |tkr2|jr,tS t jS |jrD|jrDt jS |t jkrft	|ƒt
dt ƒd  S |jrÖ|t ksŠ| t¡tt fkrŽtS |jr¦t|d ƒt j S |jrÔ| ¡ \}}|dkrÔttt j|dd�ƒS n–|j�rl|j�rlt|ƒ}||k�rt||ƒS |j�r.t j|d  t|ƒ t|d |ƒ S |t jk�rlt j|d  t|ƒ d|d  d  t|d ƒ S d S )Nr<   r3   é   F)Úevaluate)r   r?   r   r�   rŽ   rj   rX   rA   rG   r`   r   r   Zextract_multiplicativelyr   r#   Ú
EulerGammarB   Úas_numer_denomr   r7   rY   Úis_nonnegativer   r$   r   rŠ   )rI   r.   ra   rE   rC   Znzr/   r/   r0   rM   Ÿ  s2    


$zpolygamma.evalc                 C   s    | j d jr| j d jrdS d S )Nr   r3   T)r6   r@   rV   r/   r/   r0   r\   ½  s    zpolygamma._eval_is_realc                 C   s,   | j d }t|j|jgƒ}t|jt|ƒgƒS rd   )r6   r   Úis_negativerY   Z
is_complexr   )r9   ra   Zis_negative_integerr/   r/   r0   Ú_eval_is_complexÁ  s    
zpolygamma._eval_is_complexc                 C   s4   | j \}}|jr0|jr |jr dS |jr0|jr0dS d S ©NTF)r6   r@   Úis_oddÚis_realr]   ©r9   r.   ra   r/   r/   r0   r^   Æ  s    
zpolygamma._eval_is_positivec                 C   s4   | j \}}|jr0|jr |jr dS |jr0|jr0dS d S rÂ   )r6   r@   r]   rÃ   rÄ   rÅ   r/   r/   r0   Ú_eval_is_negativeÎ  s    
zpolygamma._eval_is_negativec                    sœ  | j \‰‰ˆj�r0ˆj�r0ˆjr´ˆj d ‰ ˆ jr²ˆd  ‰ˆ dkrjt‡‡fdd„tdtˆ ƒd ƒD ƒŽ }n$t‡‡fdd„ttˆ  ƒƒD ƒŽ  }tˆˆˆ  ƒtj	ˆ t
ˆƒ |  S n|ˆj�r0ˆ ¡ \‰ ‰ˆ j�r(ˆ j�r(‡ ‡‡fdd„ttˆ ƒƒD ƒ}ˆdk�rt|Ž ˆ  tˆ ƒ S t|Ž ˆ ˆd   S ˆˆ 9 ‰ˆdk�rˆj�rˆ ¡ \‰‰tj ttˆt ˆ ƒ d  tˆƒ t‡‡fdd„tdˆƒD ƒŽ  }ˆdk�rÌtˆƒ‰ˆˆ ‰|t‡fd	d„tˆƒD ƒŽ  S ˆdk �rtdˆ ƒ‰ˆˆ ‰|t‡fd
d„tˆƒD ƒŽ  S ˆdk�r*tˆƒtdt ƒd  S ˆjdk�sBˆjdk�r’tdƒ}t|ˆƒ |¡ |ˆd ¡}|tjtˆ ƒ tˆd ˆƒ  tˆ ƒ S tˆˆƒS )Nr   r3   c                    s   g | ]}t ˆ| ˆ ƒ‘qS r/   r   ©r‡   Úi©Úera   r/   r0   r‰   ß  s
   ÿ ÿz/polygamma._eval_expand_func.<locals>.<listcomp>c                    s   g | ]}t ˆ| ˆ ƒ‘qS r/   r   rÇ   rÉ   r/   r0   r‰   â  s
   ÿ ÿc                    s    g | ]}t ˆˆt|ˆ ƒ ƒ‘qS r/   )r7   r   rÇ   )rL   r.   ra   r/   r0   r‰   é  s
   ÿ ÿr<   c                    s<   g | ]4}t d | t ˆ  ˆ ƒtd t|t ˆ ƒ ƒ ‘qS ©r<   )r    r   r   r   r†   )rE   rC   r/   r0   r‰   ÷  s     c                    s   g | ]}d ˆ |  ‘qS r‹   r/   r†   ©r¢   r/   r0   r‰   ü  s     c                    s   g | ]}d ˆ d  |  ‘qS r‹   r/   r†   rÌ   r/   r0   r‰      s     éÿÿÿÿFr¡   )r6   rj   r¿   rQ   r   rH   Úintr7   r   rG   r$   Zis_MulZas_two_termsr@   r   rB   r¾   r½   r   r!   r   r`   rY   r   r   ÚdiffrP   r‚   r2   )r9   rR   rS   Zpart_1r¡   Údztr/   )rL   rÊ   r.   rE   rC   ra   r¢   r0   rO   Ö  sX    


ÿ
ÿ
&
ÿ
(ÿ


,zpolygamma._eval_expand_funcc                 K   s4   |j r0|jr0tj|d  t|ƒ t|d |ƒ S d S rd   )rY   r@   r   rG   r$   r   ©r9   r.   ra   rb   r/   r/   r0   Ú_eval_rewrite_as_zeta  s    zpolygamma._eval_rewrite_as_zetac                 K   sV   |j rR|jrt|d ƒtj S tj|d  t|ƒ t|d ƒt|d |d ƒ  S d S rd   )rY   r�   r#   r   r½   rG   r$   r   rÑ   r/   r/   r0   Ú_eval_rewrite_as_harmonic  s    z#polygamma._eval_rewrite_as_harmonicNr   c                    st   ddl m} ‡ fdd„| jD ƒ\}}||ˆ ƒ}|dkrd| dˆ  ¡rd|d krTtˆ ƒn|}| ¡ | S |  ||¡S d S )Nr   ©ÚOrderc                    s   g | ]}|  ˆ ¡‘qS r/   )rs   )r‡   r…   rˆ   r/   r0   r‰     s     z3polygamma._eval_as_leading_term.<locals>.<listcomp>r3   )r¦   rÕ   r6   Úcontainsr   Zgetnr5   )r9   rN   rm   rn   rÕ   r.   ra   r«   r/   rˆ   r0   rv     s    
zpolygamma._eval_as_leading_termr<   c                 C   s6   |dkr(| j d d… \}}t|d |ƒS t| |ƒ‚d S ©Nr<   r3   )r6   r7   r	   )r9   r:   r.   ra   r/   r/   r0   r;      s    zpolygamma.fdiffc                    sü  ddl m} |d tks0| jd jr0| jd jsBtƒ  ||||¡S | jd ‰ | jd }|dkrætˆ ƒddˆ    }d }|dk rŽ|dˆ  |ƒ}nFt	|d d ƒ}	‡ fdd„t
d|	ƒD ƒ}
|t|
Ž 8 }|dˆ |  |ƒ}| |||¡| S t|ƒ}||| dˆ    }t	|d d ƒ}	t
d|	ƒD ]^}|d| | d  d| | d  d| d| d   }|td| ƒ| ˆ d|   7 }�q|dˆ d|	   |ƒ}|dk�r¬|dˆ  |ƒ}n|dk�rÈ|dˆ d  |ƒ}| ˆ ||¡| }ddˆ  |  |  |||¡S d S )Nr   rÔ   r3   r<   c                    s,   g | ]$}t d | ƒd | ˆ d |    ‘qS rË   ©r"   r†   r·   r/   r0   r‰   8  s     z+polygamma._eval_aseries.<locals>.<listcomp>rÍ   )r¦   rÕ   r   r6   rj   r¿   rk   r©   r   r   rH   r   rl   r2   r"   )r9   r.   rª   rN   rm   rÕ   ÚNÚrr«   ÚmÚlZfacZe0rK   rq   r·   r0   r©   '  s@    
ÿ
ÿ

8$

zpolygamma._eval_aseriesc              	   C   sä   t dd„ | jD ƒƒsd S | jd  |d ¡}| jd  |d ¡}t |¡rX|dkrXtjS t|d ƒ�n t |¡r†|dkr†t ||¡}nHt 	|d |¡}t 	|d |d¡}|tj
t | ¡ |  t | ¡ }W 5 Q R X t ||¡S )Nc                 s   s   | ]}|j V  qd S r_   r“   rÇ   r/   r/   r0   r•   Q  s     z(polygamma._eval_evalf.<locals>.<genexpr>r   é   r3   )r–   r6   r—   r(   Zisintr   rA   r)   r7   r   Zeulerr‚   Zrgammar   r™   )r9   r›   r¡   ra   ru   ZztrÐ   r/   r/   r0   rœ   P  s    0zpolygamma._eval_evalf)Nr   )r<   )rw   rx   ry   rz   r|   rM   r\   rÁ   r^   rÆ   rO   rÒ   rÓ   rv   r;   r©   rœ   r}   r/   r/   rq   r0   r7   4  s   j
5


)r7   c                       sd   e Zd ZdZedd„ ƒZdd„ Zd‡ fdd	„	Z‡ fd
d„Zdd„ Z	dd„ Z
dd„ Zddd„Z‡  ZS )r`   aõ
  
    The ``loggamma`` function implements the logarithm of the
    gamma function (i.e., $\log\Gamma(x)$).

    Examples
    ========

    Several special values are known. For numerical integral
    arguments we have:

    >>> from sympy import loggamma
    >>> loggamma(-2)
    oo
    >>> loggamma(0)
    oo
    >>> loggamma(1)
    0
    >>> loggamma(2)
    0
    >>> loggamma(3)
    log(2)

    And for symbolic values:

    >>> from sympy import Symbol
    >>> n = Symbol("n", integer=True, positive=True)
    >>> loggamma(n)
    log(gamma(n))
    >>> loggamma(-n)
    oo

    For half-integral values:

    >>> from sympy import S
    >>> loggamma(S(5)/2)
    log(3*sqrt(pi)/4)
    >>> loggamma(n/2)
    log(2**(1 - n)*sqrt(pi)*gamma(n)/gamma(n/2 + 1/2))

    And general rational arguments:

    >>> from sympy import expand_func
    >>> L = loggamma(S(16)/3)
    >>> expand_func(L).doit()
    -5*log(3) + loggamma(1/3) + log(4) + log(7) + log(10) + log(13)
    >>> L = loggamma(S(19)/4)
    >>> expand_func(L).doit()
    -4*log(4) + loggamma(3/4) + log(3) + log(7) + log(11) + log(15)
    >>> L = loggamma(S(23)/7)
    >>> expand_func(L).doit()
    -3*log(7) + log(2) + loggamma(2/7) + log(9) + log(16)

    The ``loggamma`` function has the following limits towards infinity:

    >>> from sympy import oo
    >>> loggamma(oo)
    oo
    >>> loggamma(-oo)
    zoo

    The ``loggamma`` function obeys the mirror symmetry
    if $x \in \mathbb{C} \setminus \{-\infty, 0\}$:

    >>> from sympy.abc import x
    >>> from sympy import conjugate
    >>> conjugate(loggamma(x))
    loggamma(conjugate(x))

    Differentiation with respect to $x$ is supported:

    >>> from sympy import diff
    >>> diff(loggamma(x), x)
    polygamma(0, x)

    Series expansion is also supported:

    >>> from sympy import series
    >>> series(loggamma(x), x, 0, 4).cancel()
    -log(x) - EulerGamma*x + pi**2*x**2/12 - x**3*zeta(3)/3 + O(x**4)

    We can numerically evaluate the ``loggamma`` function
    to arbitrary precision on the whole complex plane:

    >>> from sympy import I
    >>> loggamma(5).evalf(30)
    3.17805383034794561964694160130
    >>> loggamma(I).evalf(20)
    -0.65092319930185633889 - 1.8724366472624298171*I

    See Also
    ========

    gamma: Gamma function.
    lowergamma: Lower incomplete gamma function.
    uppergamma: Upper incomplete gamma function.
    polygamma: Polygamma function.
    digamma: Digamma function.
    trigamma: Trigamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Gamma_function
    .. [2] https://dlmf.nist.gov/5
    .. [3] https://mathworld.wolfram.com/LogGammaFunction.html
    .. [4] https://functions.wolfram.com/GammaBetaErf/LogGamma/

    c                 C   s¨   |j r$|jrtS |jrvtt|ƒƒS nR|jrv| ¡ \}}|jrv|dkrvttt	ƒdd|   t|ƒ t|d t
j ƒ ƒS |tkr‚tS t|ƒtkr”t
jS |t
jkr¤t
jS d S r×   )rY   rX   r   r@   r   r2   Zis_rationalr¾   r   r   r   rŠ   rD   rA   r?   )rI   ra   rE   rC   r/   r/   r0   rM   Ï  s    2
zloggamma.evalc                 K   sô   ddl m} | jd }|jrð| ¡ \}}|| }|||  }|jrð|jrð||k rðtdƒ}|jr–t|| ƒ|t|ƒ  |t|d | | ƒ|d|fƒ S |j	rÞt|| ƒ|t|ƒ  t
t |  |t|| | ƒ|d| fƒ S |jrðt|| ƒS | S )Nr   ©ÚSumrK   r3   )Úsympy.concrete.summationsrß   r6   rB   r¾   r@   r   r`   r   rÀ   r   r   r�   )r9   rR   rß   ra   rE   rC   r.   rK   r/   r/   r0   rO   ã  s    
8Bzloggamma._eval_expand_funcNr   c                    sB   | j d  |d¡}|jr2| j| j Ž }| |||¡S tƒ  |||¡S rT   )r6   ri   r�   Ú_eval_rewrite_as_intractablerl   rk   )r9   rN   r.   rm   rn   ro   Úfrq   r/   r0   rl   ø  s
    zloggamma._eval_nseriesc           	         s¶   ddl m} |d tkr*tƒ  ||||¡S | jd ‰ tˆ ƒˆ tj  ˆ  tdt	 ƒd  }‡ fdd„t
d|ƒD ƒ}d }|dkrŠ|d|ƒ}n|dˆ |  |ƒ}|t|Ž   |||¡| S )Nr   rÔ   r<   c                    s<   g | ]4}t d | ƒd | d | d  ˆ d | d    ‘qS )r<   r3   rØ   r†   r·   r/   r0   r‰     s     z*loggamma._eval_aseries.<locals>.<listcomp>r3   )r¦   rÕ   r   rk   r©   r6   r   r   rŠ   r   rH   r   rl   )	r9   r.   rª   rN   rm   rÕ   rÚ   rÜ   r«   rq   r·   r0   r©   ÿ  s    
&zloggamma._eval_aseriesc                 K   s   t t|ƒƒS r_   )r   r2   rf   r/   r/   r0   rá     s    z%loggamma._eval_rewrite_as_intractablec                 C   s"   | j d }|jrdS |jrdS d S )Nr   TF)r6   r@   rX   r¹   r/   r/   r0   r\     s
    
zloggamma._eval_is_realc                 C   s,   | j d }|tjtjfkr(|  | ¡ ¡S d S rT   r�   r¹   r/   r/   r0   rW     s    
zloggamma._eval_conjugater3   c                 C   s&   |dkrt d| jd ƒS t| |ƒ‚d S r4   )r7   r6   r	   r8   r/   r/   r0   r;     s    zloggamma.fdiff)Nr   )r3   )rw   rx   ry   rz   r|   rM   rO   rl   r©   rá   r\   rW   r;   r}   r/   r/   rq   r0   r`   a  s   m
r`   c                   @   sp   e Zd ZdZdd„ Zddd„Zdd„ Zd	d
„ Zdd„ Zdd„ Z	e
dd„ ƒZdd„ Zdd„ Zdd„ Zddd„ZdS )r‚   at  
    The ``digamma`` function is the first derivative of the ``loggamma``
    function

    .. math::
        \psi(x) := \frac{\mathrm{d}}{\mathrm{d} z} \log\Gamma(z)
                = \frac{\Gamma'(z)}{\Gamma(z) }.

    In this case, ``digamma(z) = polygamma(0, z)``.

    Examples
    ========

    >>> from sympy import digamma
    >>> digamma(0)
    zoo
    >>> from sympy import Symbol
    >>> z = Symbol('z')
    >>> digamma(z)
    polygamma(0, z)

    To retain ``digamma`` as it is:

    >>> digamma(0, evaluate=False)
    digamma(0)
    >>> digamma(z, evaluate=False)
    digamma(z)

    See Also
    ========

    gamma: Gamma function.
    lowergamma: Lower incomplete gamma function.
    uppergamma: Upper incomplete gamma function.
    polygamma: Polygamma function.
    loggamma: Log Gamma function.
    trigamma: Trigamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Digamma_function
    .. [2] https://mathworld.wolfram.com/DigammaFunction.html
    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/

    c                 C   s$   | j d }t|ƒ}td|ƒj|d�S )Nr   r-   ©r6   r*   r7   Zevalf©r9   r›   ra   Znprecr/   r/   r0   rœ   T  s    
zdigamma._eval_evalfr3   c                 C   s   | j d }td|ƒ ¡ S rT   ©r6   r7   r;   ©r9   r:   ra   r/   r/   r0   r;   Y  s    
zdigamma.fdiffc                 C   s   | j d }td|ƒjS rT   ©r6   r7   rÄ   r¹   r/   r/   r0   r\   ]  s    
zdigamma._eval_is_realc                 C   s   | j d }td|ƒjS rT   ©r6   r7   r@   r¹   r/   r/   r0   r^   a  s    
zdigamma._eval_is_positivec                 C   s   | j d }td|ƒjS rT   ©r6   r7   rÀ   r¹   r/   r/   r0   rÆ   e  s    
zdigamma._eval_is_negativec                 C   s&   |   t¡}tjg| }| ||||¡S r_   )r±   r7   r   rŽ   r©   ©r9   r.   rª   rN   rm   Zas_polygammar/   r/   r0   r©   i  s    
zdigamma._eval_aseriesc                 C   s
   t d|ƒS rT   ©r7   ©rI   ra   r/   r/   r0   rM   n  s    zdigamma.evalc                 K   s   | j d }td|ƒjdd�S )Nr   T©r5   ©r6   r7   Úexpand©r9   rR   ra   r/   r/   r0   rO   r  s    
zdigamma._eval_expand_funcc                 K   s   t |d ƒtj S rd   )r#   r   r½   rf   r/   r/   r0   rÓ   v  s    z!digamma._eval_rewrite_as_harmonicc                 K   s
   t d|ƒS rT   rë   rf   r/   r/   r0   Ú_eval_rewrite_as_polygammay  s    z"digamma._eval_rewrite_as_polygammaNr   c                 C   s   | j d }td|ƒ |¡S rT   ©r6   r7   rs   ©r9   rN   rm   rn   ra   r/   r/   r0   rv   |  s    
zdigamma._eval_as_leading_term)r3   )Nr   )rw   rx   ry   rz   rœ   r;   r\   r^   rÆ   r©   r|   rM   rO   rÓ   rñ   rv   r/   r/   r/   r0   r‚   $  s   /

r‚   c                   @   sx   e Zd ZdZdd„ Zddd„Zdd„ Zd	d
„ Zdd„ Zdd„ Z	e
dd„ ƒZdd„ Zdd„ Zdd„ Zdd„ Zddd„ZdS )Útrigammaa^  
    The ``trigamma`` function is the second derivative of the ``loggamma``
    function

    .. math::
        \psi^{(1)}(z) := \frac{\mathrm{d}^{2}}{\mathrm{d} z^{2}} \log\Gamma(z).

    In this case, ``trigamma(z) = polygamma(1, z)``.

    Examples
    ========

    >>> from sympy import trigamma
    >>> trigamma(0)
    zoo
    >>> from sympy import Symbol
    >>> z = Symbol('z')
    >>> trigamma(z)
    polygamma(1, z)

    To retain ``trigamma`` as it is:

    >>> trigamma(0, evaluate=False)
    trigamma(0)
    >>> trigamma(z, evaluate=False)
    trigamma(z)


    See Also
    ========

    gamma: Gamma function.
    lowergamma: Lower incomplete gamma function.
    uppergamma: Upper incomplete gamma function.
    polygamma: Polygamma function.
    loggamma: Log Gamma function.
    digamma: Digamma function.
    sympy.functions.special.beta_functions.beta: Euler Beta function.

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Trigamma_function
    .. [2] https://mathworld.wolfram.com/TrigammaFunction.html
    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/

    c                 C   s$   | j d }t|ƒ}td|ƒj|d�S )Nr   r3   r-   rã   rä   r/   r/   r0   rœ   ²  s    
ztrigamma._eval_evalfr3   c                 C   s   | j d }td|ƒ ¡ S rh   rå   ræ   r/   r/   r0   r;   ·  s    
ztrigamma.fdiffc                 C   s   | j d }td|ƒjS rh   rç   r¹   r/   r/   r0   r\   »  s    
ztrigamma._eval_is_realc                 C   s   | j d }td|ƒjS rh   rè   r¹   r/   r/   r0   r^   ¿  s    
ztrigamma._eval_is_positivec                 C   s   | j d }td|ƒjS rh   ré   r¹   r/   r/   r0   rÆ   Ã  s    
ztrigamma._eval_is_negativec                 C   s&   |   t¡}tjg| }| ||||¡S r_   )r±   r7   r   rF   r©   rê   r/   r/   r0   r©   Ç  s    
ztrigamma._eval_aseriesc                 C   s
   t d|ƒS rd   rë   rì   r/   r/   r0   rM   Ì  s    ztrigamma.evalc                 K   s   | j d }td|ƒjdd�S )Nr   r3   Trí   rî   rð   r/   r/   r0   rO   Ð  s    
ztrigamma._eval_expand_funcc                 K   s
   t d|ƒS )Nr<   r   rf   r/   r/   r0   rÒ   Ô  s    ztrigamma._eval_rewrite_as_zetac                 K   s
   t d|ƒS rd   rë   rf   r/   r/   r0   rñ   ×  s    z#trigamma._eval_rewrite_as_polygammac                 K   s   t |d dƒ td d  S )Nr3   r<   r»   )r#   r   rf   r/   r/   r0   rÓ   Ú  s    z"trigamma._eval_rewrite_as_harmonicNr   c                 C   s   | j d }td|ƒ |¡S rh   rò   ró   r/   r/   r0   rv   Ý  s    
ztrigamma._eval_as_leading_term)r3   )Nr   )rw   rx   ry   rz   rœ   r;   r\   r^   rÆ   r©   r|   rM   rO   rÒ   rñ   rÓ   rv   r/   r/   r/   r0   rô   ‚  s   /

rô   c                   @   s:   e Zd ZdZdZddd„Zedd„ ƒZdd	„ Zd
d„ Z	dS )Ú
multigammaaÓ  
    The multivariate gamma function is a generalization of the gamma function

    .. math::
        \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2].

    In a special case, ``multigamma(x, 1) = gamma(x)``.

    Examples
    ========

    >>> from sympy import S, multigamma
    >>> from sympy import Symbol
    >>> x = Symbol('x')
    >>> p = Symbol('p', positive=True, integer=True)

    >>> multigamma(x, p)
    pi**(p*(p - 1)/4)*Product(gamma(-_k/2 + x + 1/2), (_k, 1, p))

    Several special values are known:

    >>> multigamma(1, 1)
    1
    >>> multigamma(4, 1)
    6
    >>> multigamma(S(3)/2, 1)
    sqrt(pi)/2

    Writing ``multigamma`` in terms of the ``gamma`` function:

    >>> multigamma(x, 1)
    gamma(x)

    >>> multigamma(x, 2)
    sqrt(pi)*gamma(x)*gamma(x - 1/2)

    >>> multigamma(x, 3)
    pi**(3/2)*gamma(x)*gamma(x - 1)*gamma(x - 1/2)

    Parameters
    ==========

    p : order or dimension of the multivariate gamma function

    See Also
    ========

    gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma,
    sympy.functions.special.beta_functions.beta

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function

    Tr<   c                 C   sb   ddl m} |dkrT| j\}}tdƒ}|  ||¡|td|d| d  ƒ|d|fƒ S t| |ƒ‚d S )Nr   rÞ   r<   rK   r3   )rà   rß   r6   r   r5   r7   r	   )r9   r:   rß   rN   rE   rK   r/   r/   r0   r;   "  s    
.zmultigamma.fdiffc                 C   sh   ddl m} |jdks |jdkr(tdƒ‚tdƒ}t||d  d  |t|d| d  ƒ|d|fƒ  ¡ S )	Nr   )ÚProductFz+Order parameter p must be positive integer.rK   r3   é   r<   )	Zsympy.concrete.productsrö   r@   rY   r,   r   r   r2   Zdoit)rI   rN   rE   rö   rK   r/   r/   r0   rM   +  s    &ÿzmultigamma.evalc                 C   s   | j \}}|  | ¡ |¡S r_   )r6   r5   rU   )r9   rN   rE   r/   r/   r0   rW   4  s    
zmultigamma._eval_conjugatec                 C   s^   | j \}}d| }|jr,||d kdkr,dS t|ƒrD||d krDdS ||d ksV|jrZdS d S )Nr<   r3   TF)r6   rY   r1   rZ   )r9   rN   rE   Úyr/   r/   r0   r\   8  s    
zmultigamma._eval_is_realN)r<   )
rw   rx   ry   rz   r{   r;   r|   rM   rW   r\   r/   r/   r/   r0   rõ   ç  s   8
	
rõ   N)CÚmathr   Z
sympy.corer   r   r   r   Zsympy.core.exprr   Zsympy.core.functionr   r	   r
   Zsympy.core.logicr   r   Zsympy.core.numbersr   r   r   r   Zsympy.core.powerr   Z&sympy.functions.special.zeta_functionsr   r°   r   r   r   Z$sympy.functions.elementary.complexesr   r   Z&sympy.functions.elementary.exponentialr   r   Z#sympy.functions.elementary.integersr   r   Z(sympy.functions.elementary.miscellaneousr   Z(sympy.functions.elementary.trigonometricr   r    r!   Z%sympy.functions.combinatorial.numbersr"   r#   Z(sympy.functions.combinatorial.factorialsr$   r%   r&   Zsympy.utilities.miscr'   Zmpmathr(   r)   Zmpmath.libmp.libmpfr*   r1   r2   r~   rƒ   r7   r`   r‚   rô   rõ   r/   r/   r/   r0   Ú<module>   sB    = 1 '  / D^e