a
    kh2t                     @   s`  d 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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mZmZmZmZmZmZ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, ddl-m.Z/m0Z1 dd Z2dd	 Z3d
d Z4dd Z5dd Z6dd Z7dd Z8dd Z9dd Z:dd Z;dd Z<dd Z=dd Z>d d! Z?d"d# Z@d$d% ZAd&d' ZBd(d) ZCd*d+ ZDd,d- ZEd.d/ ZFd0d1 ZGd2d3 ZHd4d5 ZId6d7 ZJd8d9 ZKd:d; ZLd<d= ZMd>d? ZNd@dA ZOdBdC ZPdDdE ZQdFdG ZRdHdI ZSdJdK ZTdLdM ZUdNdO ZVdPdQ ZWdRdS ZXdTdU ZYdVdW ZZdXdY Z[dZd[ Z\d\d] Z]djd`daZ^dbdc Z_dkdddeZ`dfdg Zadhdi Zbd^S )lzHAdvanced tools for dense recursive polynomials in ``K[x]`` or ``K[X]``.     )dup_add_termdmp_add_term
dup_lshiftdup_adddmp_adddup_subdmp_subdup_muldmp_muldup_sqrdup_divdup_remdmp_remdup_mul_grounddmp_mul_grounddup_quo_grounddmp_quo_grounddup_exquo_grounddmp_exquo_ground)	dup_strip	dmp_stripdup_convertdmp_convert
dup_degree
dmp_degreedmp_to_dictdmp_from_dictdup_LCdmp_LCdmp_ground_LCdup_TCdmp_TCdmp_zero
dmp_ground
dmp_zero_pdup_to_raw_dictdup_from_raw_dict	dmp_zerosdmp_include)MultivariatePolynomialErrorDomainError)ceillog2c              	   C   sv   |dks| s| S |j g| }tt| D ]H\}}|d }td|D ]}||| d 9 }qB|d|||| q(|S )a  
    Computes the indefinite integral of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> R.dup_integrate(x**2 + 2*x, 1)
    1/3*x**3 + x**2
    >>> R.dup_integrate(x**2 + 2*x, 2)
    1/12*x**4 + 1/3*x**3

    r      )zero	enumeratereversedrangeinsertZexquo)fmKgicnj r;   D/var/www/auris/lib/python3.9/site-packages/sympy/polys/densetools.pydup_integrate'   s    r=   c           
   	   C   s   |st | ||S |dks"t| |r&| S t||d ||d  }}tt| D ]J\}}|d }td|D ]}	|||	 d 9 }qf|dt||||| qL|S )a&  
    Computes the indefinite integral of ``f`` in ``x_0`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y = ring("x,y", QQ)

    >>> R.dmp_integrate(x + 2*y, 1)
    1/2*x**2 + 2*x*y
    >>> R.dmp_integrate(x + 2*y, 2)
    1/6*x**3 + x**2*y

    r   r-   )r=   r$   r'   r/   r0   r1   r2   r   )
r3   r4   ur5   r6   vr7   r8   r9   r:   r;   r;   r<   dmp_integrateG   s    r@   c                    sH   krt | | S |d d  t fdd| D |S )z.Recursive helper for :func:`dmp_integrate_in`.r-   c              	      s   g | ]}t | qS r;   )_rec_integrate_in.0r8   r5   r7   r:   r4   wr;   r<   
<listcomp>q       z%_rec_integrate_in.<locals>.<listcomp>)r@   r   r6   r4   r?   r7   r:   r5   r;   rD   r<   rA   j   s    rA   c                 C   s2   |dk s||kr t d||f t| ||d||S )a+  
    Computes the indefinite integral of ``f`` in ``x_j`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y = ring("x,y", QQ)

    >>> R.dmp_integrate_in(x + 2*y, 1, 0)
    1/2*x**2 + 2*x*y
    >>> R.dmp_integrate_in(x + 2*y, 1, 1)
    x*y + y**2

    r   z(0 <= j <= u expected, got u = %d, j = %d)
IndexErrorrA   r3   r4   r:   r>   r5   r;   r;   r<   dmp_integrate_int   s    rK   c                 C   s   |dkr| S t | }||k r g S g }|dkr\| d|  D ]}||||  |d8 }q:nT| d|  D ]D}|}t|d || dD ]}||9 }q||||  |d8 }qjt|S )a#  
    ``m``-th order derivative of a polynomial in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_diff(x**3 + 2*x**2 + 3*x + 4, 1)
    3*x**2 + 4*x + 3
    >>> R.dup_diff(x**3 + 2*x**2 + 3*x + 4, 2)
    6*x + 4

    r   r-   N)r   appendr1   r   )r3   r4   r5   r9   derivcoeffkr7   r;   r;   r<   dup_diff   s"    

rQ   c           
      C   s   |st | ||S |dkr| S t| |}||k r6t|S g |d  }}|dkr| d|  D ]$}|t||||| |d8 }qZnZ| d|  D ]J}|}t|d || dD ]}	||	9 }q|t||||| |d8 }qt||S )a3  
    ``m``-th order derivative in ``x_0`` of a polynomial in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1

    >>> R.dmp_diff(f, 1)
    y**2 + 2*y + 3
    >>> R.dmp_diff(f, 2)
    0

    r   r-   NrL   )rQ   r   r"   rM   r   r1   r   )
r3   r4   r>   r5   r9   rN   r?   rO   rP   r7   r;   r;   r<   dmp_diff   s&    


rR   c                    sH   krt | | S |d d  t fdd| D |S )z)Recursive helper for :func:`dmp_diff_in`.r-   c              	      s   g | ]}t | qS r;   )_rec_diff_inrB   rD   r;   r<   rF      rG   z _rec_diff_in.<locals>.<listcomp>)rR   r   rH   r;   rD   r<   rS      s    rS   c                 C   s2   |dk s||kr t d||f t| ||d||S )aS  
    ``m``-th order derivative in ``x_j`` of a polynomial in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1

    >>> R.dmp_diff_in(f, 1, 0)
    y**2 + 2*y + 3
    >>> R.dmp_diff_in(f, 1, 1)
    2*x*y + 2*x + 4*y + 3

    r   0 <= j <= %s expected, got %s)rI   rS   rJ   r;   r;   r<   dmp_diff_in   s    rU   c                 C   s8   |s| t| |S |j}| D ]}||9 }||7 }q|S )z
    Evaluate a polynomial at ``x = a`` in ``K[x]`` using Horner scheme.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_eval(x**2 + 2*x + 3, 2)
    11

    )convertr    r.   )r3   ar5   resultr8   r;   r;   r<   dup_eval  s    
rY   c                 C   sd   |st | ||S |st| |S t| ||d  }}| dd D ] }t||||}t||||}q>|S )z
    Evaluate a polynomial at ``x_0 = a`` in ``K[X]`` using the Horner scheme.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> R.dmp_eval(2*x*y + 3*x + y + 2, 2)
    5*y + 8

    r-   N)rY   r!   r   r   r   )r3   rW   r>   r5   rX   r?   rO   r;   r;   r<   dmp_eval   s    
rZ   c                    sH   krt |  S d d  t fdd| D S )z)Recursive helper for :func:`dmp_eval_in`.r-   c              	      s   g | ]}t | qS r;   )_rec_eval_inrB   r5   rW   r7   r:   r?   r;   r<   rF   D  rG   z _rec_eval_in.<locals>.<listcomp>)rZ   r   )r6   rW   r?   r7   r:   r5   r;   r\   r<   r[   =  s    r[   c                 C   s2   |dk s||kr t d||f t| ||d||S )a2  
    Evaluate a polynomial at ``x_j = a`` in ``K[X]`` using the Horner scheme.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 2*x*y + 3*x + y + 2

    >>> R.dmp_eval_in(f, 2, 0)
    5*y + 8
    >>> R.dmp_eval_in(f, 2, 1)
    7*x + 4

    r   rT   )rI   r[   )r3   rW   r:   r>   r5   r;   r;   r<   dmp_eval_inG  s    r]   c                    sf   krt |  d S  fdd| D }t  d k rH|S t |   d  S dS )z+Recursive helper for :func:`dmp_eval_tail`.rL   c                    s    g | ]}t |d   qS r-   )_rec_eval_tailrB   Ar5   r7   r>   r;   r<   rF   d  rG   z"_rec_eval_tail.<locals>.<listcomp>r-   N)rY   len)r6   r7   ra   r>   r5   hr;   r`   r<   r_   _  s    r_   c                 C   s\   |s| S t | |r"t|t| S t| d|||}|t|d krF|S t||t| S dS )a!  
    Evaluate a polynomial at ``x_j = a_j, ...`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 2*x*y + 3*x + y + 2

    >>> R.dmp_eval_tail(f, [2])
    7*x + 4
    >>> R.dmp_eval_tail(f, [2, 2])
    18

    r   r-   N)r$   r"   rb   r_   r   )r3   ra   r>   r5   er;   r;   r<   dmp_eval_taill  s    
re   c                    sT   kr t t|   S d d  t fdd| D S )z+Recursive helper for :func:`dmp_diff_eval`.r-   c              
      s    g | ]}t | qS r;   )_rec_diff_evalrB   r5   rW   r7   r:   r4   r?   r;   r<   rF     rG   z"_rec_diff_eval.<locals>.<listcomp>)rZ   rR   r   )r6   r4   rW   r?   r7   r:   r5   r;   rg   r<   rf     s    rf   c                 C   sJ   ||krt d|||f |s6tt| ||||||S t| |||d||S )a]  
    Differentiate and evaluate a polynomial in ``x_j`` at ``a`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = x*y**2 + 2*x*y + 3*x + 2*y**2 + 3*y + 1

    >>> R.dmp_diff_eval_in(f, 1, 2, 0)
    y**2 + 2*y + 3
    >>> R.dmp_diff_eval_in(f, 1, 2, 1)
    6*x + 11

    z-%s <= j < %s expected, got %sr   )rI   rZ   rR   rf   )r3   r4   rW   r:   r>   r5   r;   r;   r<   dmp_diff_eval_in  s
    rh   c                    s    j rDg }| D ]2}| }|d kr6||  q|| qn6 jrht fdd| D }nfdd| D }t|S )z
    Reduce a ``K[x]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_trunc(2*x**3 + 3*x**2 + 5*x + 7, ZZ(3))
    -x**3 - x + 1

       c                    s   g | ]} t | qS r;   )intrB   )r5   pir;   r<   rF     rG   zdup_trunc.<locals>.<listcomp>c                    s   g | ]}|  qS r;   r;   rB   )pr;   r<   rF     rG   )is_ZZrM   Zis_FiniteFieldrj   r   )r3   rl   r5   r6   r8   r;   )r5   rl   rk   r<   	dup_trunc  s    rn   c                    s   t  fdd| D S )a9  
    Reduce a ``K[X]`` polynomial modulo a polynomial ``p`` in ``K[Y]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
    >>> g = (y - 1).drop(x)

    >>> R.dmp_trunc(f, g)
    11*x**2 + 11*x + 5

    c                    s   g | ]}t |d   qS r^   )r   rB   r5   rl   r>   r;   r<   rF     rG   zdmp_trunc.<locals>.<listcomp>)r   r3   rl   r>   r5   r;   ro   r<   	dmp_trunc  s    rq   c                    s4   |st |  S |d t fdd| D |S )a   
    Reduce a ``K[X]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3

    >>> R.dmp_ground_trunc(f, ZZ(3))
    -x**2 - x*y - y

    r-   c                    s   g | ]}t | qS r;   )dmp_ground_truncrB   r5   rl   r?   r;   r<   rF     rG   z$dmp_ground_trunc.<locals>.<listcomp>)rn   r   rp   r;   rs   r<   rr     s    rr   c                 C   s0   | s| S t | |}||r | S t| ||S dS )a7  
    Divide all coefficients by ``LC(f)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x = ring("x", ZZ)
    >>> R.dup_monic(3*x**2 + 6*x + 9)
    x**2 + 2*x + 3

    >>> R, x = ring("x", QQ)
    >>> R.dup_monic(3*x**2 + 4*x + 2)
    x**2 + 4/3*x + 2/3

    N)r   is_oner   )r3   r5   lcr;   r;   r<   	dup_monic  s    

rv   c                 C   sH   |st | |S t| |r| S t| ||}||r6| S t| |||S dS )a  
    Divide all coefficients by ``LC(f)`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x,y = ring("x,y", ZZ)
    >>> f = 3*x**2*y + 6*x**2 + 3*x*y + 9*y + 3

    >>> R.dmp_ground_monic(f)
    x**2*y + 2*x**2 + x*y + 3*y + 1

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3

    >>> R.dmp_ground_monic(f)
    x**2*y + 8/3*x**2 + 5/3*x*y + 2*x + 2/3*y + 1

    N)rv   r$   r   rt   r   )r3   r>   r5   ru   r;   r;   r<   dmp_ground_monic  s    


rw   c                 C   sd   ddl m} | s|jS |j}||kr<| D ]}|||}q(n$| D ]}|||}||r@ q`q@|S )aA  
    Compute the GCD of coefficients of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x = ring("x", ZZ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_content(f)
    2

    >>> R, x = ring("x", QQ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_content(f)
    2

    r   QQ)sympy.polys.domainsry   r.   gcdrt   )r3   r5   ry   contr8   r;   r;   r<   dup_content?  s    
r}   c                 C   s   ddl m} |st| |S t| |r*|jS |j|d  }}||krb| D ]}||t|||}qFn,| D ]&}||t|||}||rf qqf|S )aa  
    Compute the GCD of coefficients of ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x,y = ring("x,y", ZZ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_content(f)
    2

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_content(f)
    2

    r   rx   r-   )rz   ry   r}   r$   r.   r{   dmp_ground_contentrt   )r3   r>   r5   ry   r|   r?   r8   r;   r;   r<   r~   i  s    


r~   c                 C   s>   | s|j | fS t| |}||r*|| fS |t| ||fS dS )at  
    Compute content and the primitive form of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x = ring("x", ZZ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_primitive(f)
    (2, 3*x**2 + 4*x + 6)

    >>> R, x = ring("x", QQ)
    >>> f = 6*x**2 + 8*x + 12

    >>> R.dup_primitive(f)
    (2, 3*x**2 + 4*x + 6)

    N)r.   r}   rt   r   )r3   r5   r|   r;   r;   r<   dup_primitive  s    


r   c                 C   sV   |st | |S t| |r"|j| fS t| ||}||r@|| fS |t| |||fS dS )a  
    Compute content and the primitive form of ``f`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ, QQ

    >>> R, x,y = ring("x,y", ZZ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_primitive(f)
    (2, x*y + 3*x + 2*y + 6)

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 2*x*y + 6*x + 4*y + 12

    >>> R.dmp_ground_primitive(f)
    (2, x*y + 3*x + 2*y + 6)

    N)r   r$   r.   r~   rt   r   )r3   r>   r5   r|   r;   r;   r<   dmp_ground_primitive  s    



r   c                 C   sL   t | |}t ||}|||}||sBt| ||} t|||}|| |fS )a  
    Extract common content from a pair of polynomials in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_extract(6*x**2 + 12*x + 18, 4*x**2 + 8*x + 12)
    (2, 3*x**2 + 6*x + 9, 2*x**2 + 4*x + 6)

    )r}   r{   rt   r   )r3   r6   r5   fcgcr{   r;   r;   r<   dup_extract  s    


r   c                 C   sT   t | ||}t |||}|||}||sJt| |||} t||||}|| |fS )a  
    Extract common content from a pair of polynomials in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> R.dmp_ground_extract(6*x*y + 12*x + 18, 4*x*y + 8*x + 12)
    (2, 3*x*y + 6*x + 9, 2*x*y + 4*x + 6)

    )r~   r{   rt   r   )r3   r6   r>   r5   r   r   r{   r;   r;   r<   dmp_ground_extract  s    
r   c           
      C   s  |j s|jstd| td}td}| s4||fS |j|jgg|jgg gg}t| d d}| dd D ](}t||d|}t|t|ddd|}qht	|}|
 D ]b\}}|d }	|	st||d|}q|	dkrt||d|}q|	dkrt||d|}qt||d|}q||fS )a  
    Find ``f1`` and ``f2``, such that ``f(x+I*y) = f1(x,y) + f2(x,y)*I``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> R.dup_real_imag(x**3 + x**2 + x + 1)
    (x**3 + x**2 - 3*x*y**2 + x - y**2 + 1, 3*x**2*y + 2*x*y - y**3 + y)

    >>> from sympy.abc import x, y, z
    >>> from sympy import I
    >>> (z**3 + z**2 + z + 1).subs(z, x+I*y).expand().collect(I)
    x**3 + x**2 - 3*x*y**2 + x - y**2 + I*(3*x**2*y + 2*x*y - y**3 + y) + 1

    z;computing real and imaginary parts is not supported over %sr-   r   ri   N   )rm   is_QQr*   r"   oner.   r#   r
   r   r%   itemsr   r   )
r3   r5   f1f2r6   rc   r8   HrP   r4   r;   r;   r<   dup_real_imag  s,    r   c                 C   s4   t | } tt| d ddD ]}| |  | |< q| S )z
    Evaluate efficiently the composition ``f(-x)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_mirror(x**3 + 2*x**2 - 4*x + 2)
    -x**3 + 2*x**2 + 4*x + 2

    ri   rL   )listr1   rb   )r3   r5   r7   r;   r;   r<   
dup_mirrorC  s    r   c                 C   sP   t | t| d |  } }}t|d ddD ]}|| |  ||  | |< }q,| S )z
    Evaluate efficiently composition ``f(a*x)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_scale(x**2 - 2*x + 1, ZZ(2))
    4*x**2 - 4*x + 1

    r-   rL   r   rb   r1   )r3   rW   r5   r9   br7   r;   r;   r<   	dup_scaleY  s    r   c                 C   sX   t | t| d  } }t|ddD ]0}td|D ] }| |d   || |  7  < q0q"| S )z
    Evaluate efficiently Taylor shift ``f(x + a)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_shift(x**2 - 2*x + 1, ZZ(2))
    x**2 + 2*x + 1

    r-   r   rL   r   )r3   rW   r5   r9   r7   r:   r;   r;   r<   	dup_shifto  s
     r   c           	         s   st | |d  S t| r"| S |d |dd  }trX fdd| D } nt| } |rt| d }t|ddD ]L}td|D ]<}t| | |d  }t| |d  |d  | |d < qq|t| S )a  
    Evaluate efficiently Taylor shift ``f(X + A)`` in ``K[X]``.

    Examples
    ========

    >>> from sympy import symbols, ring, ZZ
    >>> x, y = symbols('x y')
    >>> R, _, _ = ring([x, y], ZZ)

    >>> p = x**2*y + 2*x*y + 3*x + 4*y + 5

    >>> R.dmp_shift(R(p), [ZZ(1), ZZ(2)])
    x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22

    >>> p.subs({x: x + 1, y: y + 2}).expand()
    x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22
    r   r-   Nc                    s   g | ]}t |d   qS r^   )	dmp_shiftrB   r5   Za1r>   r;   r<   rF     rG   zdmp_shift.<locals>.<listcomp>rL   )	r   r$   anyr   rb   r1   r   r   r   )	r3   rW   r>   r5   Za0r9   r7   r:   Zafjr;   r   r<   r     s    
&r   c           	      C   s   | sg S t | d }| d g|jgg }}td|D ]}|t|d || q4t| dd |dd D ],\}}t|||}t|||}t|||}qj|S )a  
    Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_transform(x**2 - 2*x + 1, x**2 + 1, x - 1)
    x**4 - 2*x**3 + 5*x**2 - 4*x + 4

    r-   r   rL   N)rb   r   r1   rM   r	   zipr   r   )	r3   rl   qr5   r9   rc   Qr7   r8   r;   r;   r<   dup_transform  s    "r   c                 C   sf   t |dkr$tt| t|||gS | s,g S | d g}| dd D ]}t|||}t||d|}qB|S )z
    Evaluate functional composition ``f(g)`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_compose(x**2 + x, x - 1)
    x**2 - x

    r-   r   N)rb   r   rY   r   r	   r   )r3   r6   r5   rc   r8   r;   r;   r<   dup_compose  s    
r   c                 C   s\   |st | ||S t| |r| S | d g}| dd D ]"}t||||}t||d||}q4|S )z
    Evaluate functional composition ``f(g)`` in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x,y = ring("x,y", ZZ)

    >>> R.dmp_compose(x*y + 2*x + y, y)
    y**2 + 3*y

    r   r-   N)r   r$   r
   r   )r3   r6   r>   r5   rc   r8   r;   r;   r<   dmp_compose  s    

r   c                 C   s   t | d }t| |}t| } ||ji}|| }td|D ]}|j}td|D ]Z}	||	 | | vrdqN||	 |vrrqN| ||	 |  |||	   }
}||||	  |
 | 7 }qN|||| | ||| < q:t||S )+Helper function for :func:`_dup_decompose`.r-   r   )rb   r   r%   r   r1   r.   quor&   )r3   sr5   r9   ru   r6   rr7   rO   r:   r   r   r;   r;   r<   _dup_right_decompose
  s     

r   c                 C   sV   i d }}| rLt | ||\}}t|dkr.dS t||||< ||d  } }q
t||S )r   r   Nr-   )r   r   r   r&   )r3   rc   r5   r6   r7   r   r   r;   r;   r<   _dup_left_decompose&  s    
r   c                 C   sb   t | d }td|D ]F}|| dkr(qt| ||}|durt| ||}|dur||f  S qdS )z*Helper function for :func:`dup_decompose`.r-   ri   r   N)rb   r1   r   r   )r3   r5   Zdfr   rc   r6   r;   r;   r<   _dup_decompose6  s    r   c                 C   s8   g }t | |}|dur.|\} }|g| }qq.q| g| S )ae  
    Computes functional decomposition of ``f`` in ``K[x]``.

    Given a univariate polynomial ``f`` with coefficients in a field of
    characteristic zero, returns list ``[f_1, f_2, ..., f_n]``, where::

              f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))

    and ``f_2, ..., f_n`` are monic and homogeneous polynomials of at
    least second degree.

    Unlike factorization, complete functional decompositions of
    polynomials are not unique, consider examples:

    1. ``f o g = f(x + b) o (g - b)``
    2. ``x**n o x**m = x**m o x**n``
    3. ``T_n o T_m = T_m o T_n``

    where ``T_n`` and ``T_m`` are Chebyshev polynomials.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_decompose(x**4 - 2*x**3 + x**2)
    [x**2, x**2 - x]

    References
    ==========

    .. [1] [Kozen89]_

    N)r   )r3   r5   FrX   rc   r;   r;   r<   dup_decomposeI  s    $
r   c                 C   s6   |j s|jrt| ||S |jr*t| ||S tddS )a  
    Convert polynomial from ``K(a)[X]`` to ``K[a,X]``.

    Examples
    ========

    >>> from sympy.polys.densetools import dmp_alg_inject
    >>> from sympy import QQ, sqrt

    >>> K = QQ.algebraic_field(sqrt(2))

    >>> p = [K.from_sympy(sqrt(2)), K.zero, K.one]
    >>> P, lev, dom = dmp_alg_inject(p, 0, K)
    >>> P
    [[1, 0, 0], [1]]
    >>> lev
    1
    >>> dom
    QQ

    z3computation can be done only in an algebraic domainN)Zis_GaussianRingZis_GaussianField_dmp_alg_inject_gaussianZis_Algebraic_dmp_alg_inject_algr*   )r3   r>   r5   r;   r;   r<   dmp_alg_inject{  s
    r   c           	      C   sr   t | |i  } }|  D ]6\}}|j|j }}|r>||d| < |r||d| < qt||d |j}||d |jfS )+Helper function for :func:`dmp_alg_inject`.)r   r^   r-   )r   r   xyr   dom)	r3   r>   r5   rc   f_monomr6   r   r   r   r;   r;   r<   r     s    r   c           	      C   sf   t | |i  } }|  D ]*\}}|  D ]\}}|||| < q,qt||d |j}||d |jfS )r   r-   )r   r   to_dictr   r   )	r3   r>   r5   rc   r   r6   Zg_monomr8   r   r;   r;   r<   r     s    r   c           	      C   sR   ddl m} t| ||\}}}|j }t|ttd|d d|}|||||S )aO  
    Convert algebraic coefficients to integers in ``K[X]``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> from sympy import I

    >>> K = QQ.algebraic_field(I)
    >>> R, x = ring("x", K)

    >>> f = x**2 + K([QQ(1), QQ(0)])*x + K([QQ(2), QQ(0)])

    >>> R.dmp_lift(f)
    x**4 + x**2 + 4*x + 4

    r-   )dmp_resultantr   )Zeuclidtoolsr   r   modZto_listr(   r   r1   )	r3   r>   r5   r   r   r?   ZK2Zp_aZP_Ar;   r;   r<   dmp_lift  s
    
r   c                    s    fdd} j s js jr& j}nn jr: jjr:|}nZ jsF jrt	 j
dkr jj sj jjsj jr j
d jr j
d jr|}ntd   jd }}| D ] }||| r|d7 }|r|}q|S )z
    Compute the number of sign variations of ``f`` in ``K[x]``.

    Examples
    ========

    >>> from sympy.polys import ring, ZZ
    >>> R, x = ring("x", ZZ)

    >>> R.dup_sign_variations(x**4 - x**2 - x + 1)
    2

    c                    s   | sdS t  | dk S d S )NFr   )boolZto_sympy)rW   r5   r;   r<   is_negative_sympy  s    z.dup_sign_variations.<locals>.is_negative_sympyr-   r   z-sign variation counting not supported over %s)rm   r   Zis_RRis_negativeZis_AlgebraicFieldextZis_comparableZis_PolynomialRingZis_FractionFieldrb   symbolsr   Zis_transcendentalr*   r.   )r3   r5   r   r   prevrP   rO   r;   r   r<   dup_sign_variations  s2    

r   NFc                    s   du r j r  n j| D ]} |q&rd|sT| fS t|  fS  fdd| D } |st|  fS | fS dS )a@  
    Clear denominators, i.e. transform ``K_0`` to ``K_1``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = QQ(1,2)*x + QQ(1,3)

    >>> R.dup_clear_denoms(f, convert=False)
    (6, 3*x + 2)
    >>> R.dup_clear_denoms(f, convert=True)
    (6, 3*x + 2)

    Nc              	      s(   g | ] }  | | qS r;   )Znumerr   denomrB   K0K1commonr;   r<   rF   0  rG   z$dup_clear_denoms.<locals>.<listcomp>)has_assoc_Ringget_ringr   lcmr   rt   r   )r3   r   r   rV   r8   r;   r   r<   dup_clear_denoms  s    

r   c              	   C   sT   |j }|s(| D ]}||||}qn(|d }| D ]}||t||||}q4|S )z.Recursive helper for :func:`dmp_clear_denoms`.r-   )r   r   r   _rec_clear_denoms)r6   r?   r   r   r   r8   rE   r;   r;   r<   r   8  s    r   c                 C   sx   |st | |||dS |du r0|jr,| }n|}t| |||}||sVt| |||} |sb|| fS |t| |||fS dS )aV  
    Clear denominators, i.e. transform ``K_0`` to ``K_1``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y = ring("x,y", QQ)

    >>> f = QQ(1,2)*x + QQ(1,3)*y + 1

    >>> R.dmp_clear_denoms(f, convert=False)
    (6, 3*x + 2*y + 6)
    >>> R.dmp_clear_denoms(f, convert=True)
    (6, 3*x + 2*y + 6)

    )rV   N)r   r   r   r   rt   r   r   )r3   r>   r   r   rV   r   r;   r;   r<   dmp_clear_denomsH  s    

r   c           	      C   s   | t| |g}|j|j|jg}ttt|}td|d D ]J}t||d|}t	| t
|||}tt|||||}t|t||}q@|S )a  
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

    This function computes first ``2**n`` terms of a polynomial that
    is a result of inversion of a polynomial modulo ``x**n``. This is
    useful to efficiently compute series expansion of ``1/f``.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x = ring("x", QQ)

    >>> f = -QQ(1,720)*x**6 + QQ(1,24)*x**4 - QQ(1,2)*x**2 + 1

    >>> R.dup_revert(f, 8)
    61/720*x**6 + 5/24*x**4 + 1/2*x**2 + 1

    r-   ri   )revertr    r   r.   rj   _ceil_log2r1   r   r	   r   r   r   r   r   )	r3   r9   r5   r6   rc   Nr7   rW   r   r;   r;   r<   
dup_revertn  s    r   c                 C   s   |st | ||S t| |dS )z
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

    Examples
    ========

    >>> from sympy.polys import ring, QQ
    >>> R, x,y = ring("x,y", QQ)

    N)r   r)   )r3   r6   r>   r5   r;   r;   r<   
dmp_revert  s    r   )NF)NF)c__doc__Zsympy.polys.densearithr   r   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   Zsympy.polys.densebasicr   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   Zsympy.polys.polyerrorsr)   r*   mathr+   r   r,   r   r=   r@   rA   rK   rQ   rR   rS   rU   rY   rZ   r[   r]   r_   re   rf   rh   rn   rq   rr   rv   rw   r}   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r;   r;   r;   r<   <module>   sj   TX #
+/

 
"$*-!$4+27
-
&"