o
    ohj                     @   sT  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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) ddl*m+Z+m,Z, ddl-m.Z. ddl/m0Z1m2Z3 d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, ZFd-d. ZGd/d0 ZHd1d2 ZId3d4 ZJd5d6 ZKd7d8 ZLd9d: ZMd;d< ZNd=d> ZOd?d@ ZPdAdB ZQdCdD ZRdEdF ZSdGdH ZTdIdJ ZUdKdL ZVdMdN ZWdOdP ZXdQdR ZYdSdT ZZdUdV Z[dWdX Z\ded[d\Z]d]d^ Z^ded_d`Z_dadb Z`dcdd ZadYS )fzHAdvanced 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
dmp_expand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)MultivariatePolynomialErrorDomainError)
variations)ceillog2c              	   C   sv   |dks| s| S |j g| }tt| D ]$\}}|d }td|D ]
}||| d 9 }q!|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insertexquo)fmKgicnj r=   j/var/www/html/construction_image-detection-poc/venv/lib/python3.10/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 ]%\}}|d }td|D ]
}	|||	 d 9 }q3|dt||||| q&|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(   r0   r1   r2   r3   r   )
r5   r6   ur7   r8   vr9   r:   r;   r<   r=   r=   r>   dmp_integrateG   s   rB   c                    H   krt | | S |d d t fdd| D |S )z.Recursive helper for :func:`dmp_integrate_in`.r.   c              	         g | ]}t | qS r=   )_rec_integrate_in.0r:   r7   r9   r<   r6   wr=   r>   
<listcomp>q       z%_rec_integrate_in.<locals>.<listcomp>)rB   r   r8   r6   rA   r9   r<   r7   r=   rH   r>   rE   j       rE   c                 C   2   |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)
IndexErrorrE   r5   r6   r<   r@   r7   r=   r=   r>   dmp_integrate_int   s   rQ   c                 C   s   |dkr| S t | }||k rg S g }|dkr1| d|  D ]}||||  |d8 }qt|S | d|  D ]"}|}t|d || dD ]}||9 }qF||||  |d8 }q8t|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   appendr2   r   )r5   r6   r7   r;   derivcoeffkr9   r=   r=   r>   dup_diff   s$   


rW   c           
      C   s   |st | ||S |dkr| S t| |}||k rt|S g |d }}|dkrA| d|  D ]}|t||||| |d8 }q-n-| d|  D ]%}|}t|d || dD ]}	||	9 }qV|t||||| |d8 }qHt||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.   NrR   )rW   r   r#   rS   r   r2   r   )
r5   r6   r@   r7   r;   rT   rA   rU   rV   r9   r=   r=   r>   dmp_diff   s(   




rX   c                    rC   )z)Recursive helper for :func:`dmp_diff_in`.r.   c              	      rD   r=   )_rec_diff_inrF   rH   r=   r>   rJ      rK   z _rec_diff_in.<locals>.<listcomp>)rX   r   rL   r=   rH   r>   rY      rM   rY   c                 C   rN   )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)rO   rY   rP   r=   r=   r>   dmp_diff_in      r[   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/   )r5   ar7   resultr:   r=   r=   r>   dup_eval  s   
r`   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)r`   r"   r   r   r   )r5   r^   r@   r7   r_   rA   rU   r=   r=   r>   dmp_eval   s   
ra   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_inrF   r7   r^   r9   r<   rA   r=   r>   rJ   D  rK   z _rec_eval_in.<locals>.<listcomp>)ra   r   )r8   r^   rA   r9   r<   r7   r=   rc   r>   rb   =  rM   rb   c                 C   rN   )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   rZ   )rO   rb   )r5   r^   r<   r@   r7   r=   r=   r>   dmp_eval_inG  r\   rd   c                    sb   krt |  d S  fdd| D }t  d k r$|S t |   d  S )z+Recursive helper for :func:`dmp_eval_tail`.rR   c                    s    g | ]}t |d   qS r.   )_rec_eval_tailrF   Ar7   r9   r@   r=   r>   rJ   d       z"_rec_eval_tail.<locals>.<listcomp>r.   )r`   len)r8   r9   rh   r@   r7   hr=   rg   r>   rf   _  s   rf   c                 C   sX   |s| S t | |rt|t| S t| d|||}|t|d kr#|S t||t| 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.   )r%   r#   rj   rf   r   )r5   rh   r@   r7   er=   r=   r>   dmp_eval_taill  s   
rm   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_evalrF   r7   r^   r9   r<   r6   rA   r=   r>   rJ     ri   z"_rec_diff_eval.<locals>.<listcomp>)ra   rX   r   )r8   r6   r^   rA   r9   r<   r7   r=   ro   r>   rn     s   "rn   c                 C   sJ   ||krt d|||f |st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   )rO   ra   rX   rn   )r5   r6   r^   r<   r@   r7   r=   r=   r>   dmp_diff_eval_in  s
   rp   c                    s    j r%g }| D ]}| }|d kr||  q|| qt|S  jr:t fdd| D }t|S 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=   )intrF   )r7   pir=   r>   rJ     s    zdup_trunc.<locals>.<listcomp>c                    s   g | ]}|  qS r=   r=   rF   )pr=   r>   rJ     s    )is_ZZrS   is_FiniteFieldrr   r   )r5   rt   r7   r8   r:   r=   )r7   rt   rs   r>   	dup_trunc  s   rw   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                       g | ]}t |d   qS re   )r   rF   r7   rt   r@   r=   r>   rJ     rK   zdmp_trunc.<locals>.<listcomp>)r   r5   rt   r@   r7   r=   ry   r>   	dmp_trunc  s   r{   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_truncrF   r7   rt   rA   r=   r>   rJ     s    z$dmp_ground_trunc.<locals>.<listcomp>)rw   r   rz   r=   r}   r>   r|     s   r|   c                 C   s,   | s| S t | |}||r| S t| ||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

    )r   is_oner   )r5   r7   lcr=   r=   r>   	dup_monic  s   

r   c                 C   sD   |st | |S t| |r| S t| ||}||r| S t| |||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

    )r   r%   r    r~   r   )r5   r@   r7   r   r=   r=   r>   dmp_ground_monic  s   


r   c                 C   sh   ddl m} | s|jS |j}||kr| D ]}|||}q|S | D ]}|||}||r1 |S 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.domainsr   r/   gcdr~   )r5   r7   r   contr:   r=   r=   r>   dup_content?  s   
r   c                 C   s   ddl m} |st| |S t| |r|jS |j|d }}||kr2| D ]}||t|||}q#|S | D ]}||t|||}||rH |S q4|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   r   r.   )r   r   r   r%   r/   r   dmp_ground_contentr~   )r5   r@   r7   r   r   rA   r:   r=   r=   r>   r   i  s"   


r   c                 C   s:   | s|j | fS t| |}||r|| fS |t| ||f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)

    )r/   r   r~   r   )r5   r7   r   r=   r=   r>   dup_primitive  s   


r   c                 C   sR   |st | |S t| |r|j| fS t| ||}||r || fS |t| |||f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)

    )r   r%   r/   r   r~   r   )r5   r@   r7   r   r=   r=   r>   dmp_ground_primitive  s   



r   c                 C   sL   t | |}t ||}|||}||s!t| ||} 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   r~   r   )r5   r8   r7   fcgcr   r=   r=   r>   dup_extract  s   



r   c                 C   sT   t | ||}t |||}|||}||s%t| |||} 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   r~   r   )r5   r8   r@   r7   r   r   r   r=   r=   r>   dmp_ground_extract  s   

r   c           
      C   s  |j s|jstd| td}td}| s||fS |j|jgg|jgg gg}t| d d}| dd D ]}t||d|}t|t|ddd|}q4t	|}|
 D ]1\}}|d }	|	sct||d|}qQ|	dkrot||d|}qQ|	dkr{t||d|}qQt||d|}qQ||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   rq   N   )ru   is_QQr*   r#   oner/   r$   r
   r   r&   itemsr   r   )
r5   r7   f1f2r8   rk   r:   HrV   r6   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

    rq   rR   )listr2   rj   )r5   r7   r9   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.   rR   r   rj   r2   )r5   r^   r7   r;   br9   r=   r=   r>   	dup_scaleY  s   r   c                 C   sX   t | t| d } }t|ddD ]}td|D ]}| |d   || |  7  < qq| 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   rR   r   )r5   r^   r7   r;   r9   r<   r=   r=   r>   	dup_shifto  s   r   c           	         s   s
t | |d  S t| r| S |d |dd } fdd| D } t| d }t|ddD ]&}td|D ]}t| | |d  }t| |d  |d  | |d < q:q3| 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                    rx   re   )	dmp_shiftrF   r7   a1r@   r=   r>   rJ     rK   zdmp_shift.<locals>.<listcomp>rR   )r   r%   rj   r2   r   r   )	r5   r^   r@   r7   a0r;   r9   r<   afjr=   r   r>   r     s   
$r   c           	      C   s   | sg S t | d }| d g|jgg}}td|D ]}|t|d || qt| dd |dd D ]\}}t|||}t|||}t|||}q5|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   rR   N)rj   r   r2   rS   r	   zipr   r   )	r5   rt   qr7   r;   rk   Qr9   r:   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|}q!|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)rj   r   r`   r   r	   r   )r5   r8   r7   rk   r:   r=   r=   r>   dup_compose  s   
r   c                 C   s\   |st | ||S t| |r| S | d g}| dd D ]}t||||}t||d||}q|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   )r5   r8   r@   r7   rk   r:   r=   r=   r>   dmp_compose  s   

r   c                 C   s   t | d }t| |}t| } ||ji}|| }td|D ]F}|j}td|D ]-}	||	 | | vr2q'||	 |vr9q'| ||	 |  |||	  }
}||||	  |
 | 7 }q'|||| | ||| < qt||S )+Helper function for :func:`_dup_decompose`.r.   r   )rj   r   r&   r   r2   r/   quor'   )r5   sr7   r;   r   r8   rr9   rU   r<   r   r   r=   r=   r>   _dup_right_decompose  s    


r   c                 C   sX   i d}}| r't | ||\}}t|dkrdS t||||< ||d } }| st||S )r   r   Nr.   )r   r   r   r'   )r5   rk   r7   r8   r9   r   r   r=   r=   r>   _dup_left_decompose!  s   

	r   c                 C   sb   t | d }td|D ]#}|| 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.   rq   r   N)rj   r2   r   r   )r5   r7   dfr   rk   r8   r=   r=   r>   _dup_decompose1  s   r   c                 C   s:   g }	 t | |}|dur|\} }|g| }nn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]_

    TN)r   )r5   r7   Fr_   rk   r=   r=   r>   dup_decomposeD  s   $

	r   c                 C   s   |j r| }t| |||} |}|jstdt| |g g }}}| D ]\}}|js2|| q&t	ddgt
|dd}	|	D ]$}
t|}t|
|D ]\}}|dkrZ||  ||< qK|t||| q@tt||||||jS )a^  
    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**8 + 2*x**6 + 9*x**4 - 8*x**2 + 16

    z3computation can be done only in an algebraic domainrR   r.   T)
repetition)is_GaussianFieldas_AlgebraicFieldr   is_Algebraicr*   r   r   	is_groundrS   r+   rj   dictr   r   r   dom)r5   r@   r7   K1r   monomspolysmonomrU   permspermGsignr=   r=   r>   dmp_liftv  s,   
r   c                 C   s8   |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

    r   r.   )r/   is_negative)r5   r7   prevrV   rU   r=   r=   r>   dup_sign_variations  s   r   NFc                    s   du r j r  n j| D ]} |qr2|s*| fS t|  fS  fdd| D } |sGt|  fS | f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=   )numerr   denomrF   K0r   commonr=   r>   rJ     s   ( z$dup_clear_denoms.<locals>.<listcomp>)has_assoc_Ringget_ringr   lcmr   r~   r   )r5   r   r   r]   r:   r=   r   r>   dup_clear_denoms  s   

r   c              	   C   sV   |j }|s| D ]}||||}q|S |d }| D ]}||t||||}q|S )z.Recursive helper for :func:`dmp_clear_denoms`.r.   )r   r   r   _rec_clear_denoms)r8   rA   r   r   r   r:   rI   r=   r=   r>   r     s   r   c                 C   st   |s
t | |||dS |du r|jr| }n|}t| |||}||s+t| |||} |s1|| fS |t| |||f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)

    )r]   N)r   r   r   r   r~   r   r   )r5   r@   r   r   r]   r   r=   r=   r>   dmp_clear_denoms  s   

r   c           	      C   s   | t| |g}|j|j|jg}ttt|}td|d D ]%}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.   rq   )revertr!   r   r/   rr   _ceil_log2r2   r   r	   r   r   r   r   r   )	r5   r;   r7   r8   rk   Nr9   r^   r   r=   r=   r>   
dup_revert#  s   r   c                 C   s   |st | ||S t| |)z
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

    Examples
    ========

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

    )r   r)   )r5   r8   r@   r7   r=   r=   r>   
dmp_revertE  s   
r   )NF)b__doc__sympy.polys.densearithr   r   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   sympy.polys.densebasicr   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   sympy.polys.polyerrorsr)   r*   sympy.utilitiesr+   mathr,   r   r-   r   r?   rB   rE   rQ   rW   rX   rY   r[   r`   ra   rb   rd   rf   rm   rn   rp   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=   r>   <module>   sh    XT #
+/

 
"$*-!$4&20
-
&"