B
    ˜‘[†(  ã               @   s–   d Z ddlmZmZ ddlmZmZmZmZm	Z	m
Z
mZmZmZmZmZ ddlmZmZmZ ddlmZ dd„ Zdd	„ Zddd„Zdd„ Zdd„ Zd
S )zAThis module implements tools for integrating rational functions. é    )Úprint_functionÚdivision)ÚSÚSymbolÚsymbolsÚIÚlogÚatanÚrootsÚRootSumÚLambdaÚcancelÚDummy)ÚPolyÚ	resultantÚZZ)Úrangec          
   K   sF  t | ƒtk	r|  ¡ \}}n| \}}t||dddt||ddd }}| |¡\}}}| |¡\}}| |¡ ¡ }|jr~|| S t	|||ƒ\}}	|	 ¡ \}
}t|
|ƒ}
t||ƒ}|
 |¡\}}||| |¡ ¡  7 }|js>| 
dd¡}t|tƒsút|ƒ}n| ¡ }t||||ƒ}| 
d¡}|dkr|t | ƒtk	r<|  ¡ }n| \}}| ¡ | ¡ B }x&||h D ]}|js`d}P q`W d}tdƒ}|sÐxª|D ]:\}	}|	 ¡ \}}	|t|t||t|	 ¡ ƒ ƒdd	7 }qW nfxd|D ]\\}	}|	 ¡ \}}	t|	|||ƒ}|dk	r||7 }n$|t|t||t|	 ¡ ƒ ƒdd	7 }qÖW ||7 }|| S )
a  Performs indefinite integration of rational functions.

       Given a field :math:`K` and a rational function :math:`f = p/q`,
       where :math:`p` and :math:`q` are polynomials in :math:`K[x]`,
       returns a function :math:`g` such that :math:`f = g'`.

       >>> from sympy.integrals.rationaltools import ratint
       >>> from sympy.abc import x

       >>> ratint(36/(x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2), x)
       (12*x + 6)/(x**2 - 1) + 4*log(x - 2) - 4*log(x + 1)

       References
       ==========

       .. [Bro05] M. Bronstein, Symbolic Integration I: Transcendental
          Functions, Second Edition, Springer-Verlag, 2005, pp. 35-70

       See Also
       ========

       sympy.integrals.integrals.Integral.doit
       ratint_logpart, ratint_ratpart
    FT)Ú	compositeÚfieldÚsymbolÚtÚrealNr   )Z	quadratic)ÚtypeÚtupleZas_numer_denomr   r   ÚdivZ	integrateÚas_exprÚis_zeroÚratint_ratpartÚgetÚ
isinstancer   r   Zas_dummyÚratint_logpartÚatomsZis_realr   Ú	primitiver   r   r   Úlog_to_real)ÚfÚxÚflagsÚpÚqÚcoeffZpolyÚresultÚgÚhÚPÚQÚrr   r   ÚLr   r!   ZeltZepsÚ_ÚR© r3   ú<lib/python3.7/site-packages/sympy/integrals/rationaltools.pyÚratint   s^    "






(

&r5   c                s$  ddl m} t| |ƒ} t||ƒ}| | ¡ ¡\}}}| ¡ ‰| ¡ ‰ ‡fdd„tdˆƒD ƒ}‡ fdd„tdˆ ƒD ƒ}|| }	t||t|	 d}
t||t|	 d}| |
 ¡ |  |
| ¡ |  |¡  ||  }|| 	¡ |	ƒ}|
 
¡  |¡}
| 
¡  |¡}t|
| 
¡  |ƒ}t|| 
¡  |ƒ}||fS )aŠ  
    Horowitz-Ostrogradsky algorithm.

    Given a field K and polynomials f and g in K[x], such that f and g
    are coprime and deg(f) < deg(g), returns fractions A and B in K(x),
    such that f/g = A' + B and B has square-free denominator.

    Examples
    ========

        >>> from sympy.integrals.rationaltools import ratint_ratpart
        >>> from sympy.abc import x, y
        >>> from sympy import Poly
        >>> ratint_ratpart(Poly(1, x, domain='ZZ'),
        ... Poly(x + 1, x, domain='ZZ'), x)
        (0, 1/(x + 1))
        >>> ratint_ratpart(Poly(1, x, domain='EX'),
        ... Poly(x**2 + y**2, x, domain='EX'), x)
        (0, 1/(x**2 + y**2))
        >>> ratint_ratpart(Poly(36, x, domain='ZZ'),
        ... Poly(x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2, x, domain='ZZ'), x)
        ((12*x + 6)/(x**2 - 1), 12/(x**2 - x - 2))

    See Also
    ========

    ratint, ratint_logpart
    r   )Úsolvec                s    g | ]}t d tˆ | ƒ ƒ‘qS )Úa)r   Ústr)Ú.0Úi)Únr3   r4   ú
<listcomp>—   s    z"ratint_ratpart.<locals>.<listcomp>c                s    g | ]}t d tˆ | ƒ ƒ‘qS )Úb)r   r8   )r9   r:   )Úmr3   r4   r<   ˜   s    )Zdomain)Úsympyr6   r   Z	cofactorsÚdiffÚdegreer   r   ÚquoÚcoeffsr   Úsubsr   )r$   r+   r%   r6   ÚuÚvr1   ZA_coeffsZB_coeffsZC_coeffsÚAÚBÚHr*   Zrat_partZlog_partr3   )r>   r;   r4   r   p   s$    

.r   Nc             C   sÐ  t | |ƒt ||ƒ } }|p tdƒ}|| | ¡ t ||ƒ   }}t||dd\}}t ||dd}|srtd||f ƒ‚i g  }}	x|D ]}
|
||
 ¡ < q‚W dd„ }| ¡ \}}|||ƒ x|D ]
\}}| ¡ \}}| ¡ |krî|	 ||f¡ q¼|| }t | 	¡ |dd	}|jdd
\}}|||ƒ x,|D ]$\}}| 
t | |¡| |ƒ¡}q(W | |¡tdƒg }}x6| ¡ dd… D ]"}||  |¡}| | ¡ ¡ qxW t ttt| ¡ |ƒƒƒ|ƒ}|	 ||f¡ q¼W |	S )aw  
    Lazard-Rioboo-Trager algorithm.

    Given a field K and polynomials f and g in K[x], such that f and g
    are coprime, deg(f) < deg(g) and g is square-free, returns a list
    of tuples (s_i, q_i) of polynomials, for i = 1..n, such that s_i
    in K[t, x] and q_i in K[t], and:
                           ___    ___
                 d  f   d  \  `   \  `
                 -- - = --  )      )   a log(s_i(a, x))
                 dx g   dx /__,   /__,
                          i=1..n a | q_i(a) = 0

    Examples
    ========

        >>> from sympy.integrals.rationaltools import ratint_logpart
        >>> from sympy.abc import x
        >>> from sympy import Poly
        >>> ratint_logpart(Poly(1, x, domain='ZZ'),
        ... Poly(x**2 + x + 1, x, domain='ZZ'), x)
        [(Poly(x + 3*_t/2 + 1/2, x, domain='QQ[_t]'),
        ...Poly(3*_t**2 + 1, _t, domain='ZZ'))]
        >>> ratint_logpart(Poly(12, x, domain='ZZ'),
        ... Poly(x**2 - x - 2, x, domain='ZZ'), x)
        [(Poly(x - 3*_t/8 - 1/2, x, domain='QQ[_t]'),
        ...Poly(-_t**2 + 16, _t, domain='ZZ'))]

    See Also
    ========

    ratint, ratint_ratpart
    r   T)Z
includePRSF)r   z$BUG: resultant(%s, %s) can't be zeroc             S   s,   | dk dkr(|d \}}||  |f|d< d S )Nr   Tr3   )ÚcZsqfr,   Úkr3   r3   r4   Ú_include_signÝ   s    z%ratint_logpart.<locals>._include_sign)r   )Úallé   N)r   r   r@   r   ÚAssertionErrorrA   Zsqf_listr"   ÚappendZLCrB   ZgcdÚinvertr   rC   Zremr   ÚdictÚlistÚzipZmonoms)r$   r+   r%   r   r7   r=   Zresr2   ZR_maprI   r/   rL   ÚCZres_sqfr(   r:   r1   r,   Zh_lcrJ   Zh_lc_sqfÚjÚinvrC   r)   ÚTr3   r3   r4   r    ¬   s:    "



 r    c       	      C   sš   |   ¡ |  ¡ k r| |  } }|  ¡ } | ¡ }|  |¡\}}|jrPdt| ¡ ƒ S | |  ¡\}}}| | ||   |¡}dt| ¡ ƒ }|t||ƒ S dS )a  
    Convert complex logarithms to real arctangents.

    Given a real field K and polynomials f and g in K[x], with g != 0,
    returns a sum h of arctangents of polynomials in K[x], such that:

                   dh   d         f + I g
                   -- = -- I log( ------- )
                   dx   dx        f - I g

    Examples
    ========

        >>> from sympy.integrals.rationaltools import log_to_atan
        >>> from sympy.abc import x
        >>> from sympy import Poly, sqrt, S
        >>> log_to_atan(Poly(x, x, domain='ZZ'), Poly(1, x, domain='ZZ'))
        2*atan(x)
        >>> log_to_atan(Poly(x + S(1)/2, x, domain='QQ'),
        ... Poly(sqrt(3)/2, x, domain='EX'))
        2*atan(2*sqrt(3)*x/3 + sqrt(3)/3)

    See Also
    ========

    log_to_real
    é   N)	rA   Zto_fieldr   r   r	   r   ZgcdexrB   Úlog_to_atan)	r$   r+   r'   r(   Úsr   r,   rE   rG   r3   r3   r4   rZ     s    rZ   c          	   C   s”  ddl m} tdtd\}}|  ¡  ||t|  i¡ ¡ }| ¡  ||t|  i¡ ¡ }||tdd}	||tdd}
|	 t	dƒt	dƒ¡|	 tt	dƒ¡ }}|
 t	dƒt	dƒ¡|
 tt	dƒ¡ }}t
t|||ƒ|ƒ}t|dd	}t|ƒ| ¡ kròd
S t	dƒ}x@| ¡ D ]2}t
| ||i¡|ƒ}t|dd	}t|ƒ| ¡ krBd
S g }xV|D ]N}||krL| |krL|jsx| ¡ r†| | ¡ n|jsL| |¡ qLW x˜|D ]}| ||||i¡}|jdddkrÐq¤t
| ||||i¡|ƒ}t
| ||||i¡|ƒ}|d |d   ¡ }||t|ƒ |t||ƒ  7 }q¤W qW t|dd	}t|ƒ| ¡ kr`d
S x.| ¡ D ]"}||t|  ¡  ||¡ƒ 7 }qjW |S )a\  
    Convert complex logarithms to real functions.

    Given real field K and polynomials h in K[t,x] and q in K[t],
    returns real function f such that:
                          ___
                  df   d  \  `
                  -- = --  )  a log(h(a, x))
                  dx   dx /__,
                         a | q(a) = 0

    Examples
    ========

        >>> from sympy.integrals.rationaltools import log_to_real
        >>> from sympy.abc import x, y
        >>> from sympy import Poly, sqrt, S
        >>> log_to_real(Poly(x + 3*y/2 + S(1)/2, x, domain='QQ[y]'),
        ... Poly(3*y**2 + 1, y, domain='ZZ'), x, y)
        2*sqrt(3)*atan(2*sqrt(3)*x/3 + sqrt(3)/3)/3
        >>> log_to_real(Poly(x**2 - 1, x, domain='ZZ'),
        ... Poly(-2*y + 1, y, domain='ZZ'), x, y)
        log(x**2 - 1)/2

    See Also
    ========

    log_to_atan
    r   )Úcollectzu,v)ÚclsF)ZevaluaterN   r2   )ÚfilterNT)ZchoprY   )r?   r\   r   r   r   rD   r   Úexpandr   r   r   r   r
   ÚlenZcount_rootsÚkeysZis_negativeZcould_extract_minus_signrP   r   Zevalfr   rZ   )r,   r(   r%   r   r\   rE   rF   rI   r.   ZH_mapZQ_mapr7   r=   rJ   Údr2   ZR_ur*   Zr_urU   ZR_vZ
R_v_pairedZr_vÚDrG   rH   ZABZR_qr/   r3   r3   r4   r#   /  sN    &&

*"r#   )N)Ú__doc__Z
__future__r   r   r?   r   r   r   r   r   r	   r
   r   r   r   r   Zsympy.polysr   r   r   Zsympy.core.compatibilityr   r5   r   r    rZ   r#   r3   r3   r3   r4   Ú<module>   s   4e<
U.