§
    ^²Åj°j  ã                   óú  — 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„ Z4d„ Z5d	„ Z6d
„ Z7d„ Z8d„ Z9d„ Z:d„ Z;d„ Z<d„ Z=d„ Z>d„ Z?d„ Z@d„ ZAd„ ZBd„ ZCd„ ZDd„ ZEd„ ZFd„ ZGd„ ZHd„ ZId„ ZJd„ ZKd„ ZLd „ ZMd!„ ZNd"„ ZOd#„ ZPd$„ ZQd%„ ZRd&„ ZSd'„ ZTd(„ ZUd)„ ZVd*„ ZWd+„ ZXd,„ ZYd-„ ZZd.„ Z[d/„ Z\d7d2„Z]d3„ Z^d7d4„Z_d5„ Z`d6„ Zad0S )8zHAdvanced 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           
      ó   — |dk    s| s| S |j         g|z  }t          t          | ¦  «        ¦  «        D ][\  }}|dz   }t          d|¦  «        D ]}|||z   dz   z  }Œ|                     d|                     | ||¦  «        ¦  «        ¦  «         Œ\|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Újs           úGC:\Projects\Historical\venv\Lib\site-packages\sympy/polys/densetools.pyÚdup_integrater@   '   s©   € ð  	ˆA‚v€v�Q€vØˆà	
Œˆ�‰
€Aå�( 1™+œ+Ñ&Ô&ð &ð &‰ˆˆ1Ø�‰Eˆå�q˜!‘”ð 	ð 	ˆAØ��Q‘˜‘‰NˆAˆAà	�Š��A—G’G˜A˜q˜q ™tœtÑ$Ô$Ñ%Ô%Ð%Ð%à€Hó    c           
      óv  — |st          | ||¦  «        S |dk    st          | |¦  «        r| S t          ||dz
  |¦  «        |dz
  }}t          t	          | ¦  «        ¦  «        D ]W\  }}|dz   }t          d|¦  «        D ]}	|||	z   dz   z  }Œ|                     dt          | ||¦  «        ||¦  «        ¦  «         ŒX|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   r0   )r@   r&   r)   r2   r3   r4   r5   r   )
r7   r8   Úur9   r:   Úvr;   r<   r=   r>   s
             r?   Údmp_integraterE   G   sÝ   € ð  ð &Ý˜Q  1Ñ%Ô%Ð%àˆA‚v€v•˜A˜qÑ!Ô!€vØˆå�Q˜˜A™˜qÑ!Ô! 1 q¡5€q€Aå�( 1™+œ+Ñ&Ô&ð 3ð 3‰ˆˆ1Ø�‰Eˆå�q˜!‘”ð 	ð 	ˆAØ��Q‘˜‘‰NˆAˆAà	�Š�•N 1 a a¨¡d¤d¨A¨qÑ1Ô1Ñ2Ô2Ð2Ð2à€HrA   c                 ó’   ‡‡‡‡‡— ‰‰k    rt          | ‰|‰¦  «        S |dz
  ‰dz   cŠŠt          ˆˆˆˆˆfd„| D ¦   «         |¦  «        S )z.Recursive helper for :func:`dmp_integrate_in`.r0   c           
      ó8   •— g | ]}t          |‰‰‰‰‰¦  «        ‘ŒS © )Ú_rec_integrate_in©Ú.0r<   r9   r;   r>   r8   Úws     €€€€€r?   ú
<listcomp>z%_rec_integrate_in.<locals>.<listcomp>q   s,   ø€ ÐGÐGÐG¸qÕ(¨¨A¨q°!°Q¸Ñ:Ô:ÐGÐGÐGrA   )rE   r   ©r:   r8   rD   r;   r>   r9   rL   s    ` ```@r?   rI   rI   j   sh   øøøøø€ àˆA‚v€vÝ˜Q  1 aÑ(Ô(Ð(àˆq‰5�!�a‘%€D€A€qåÐGÐGÐGÐGÐGÐGÐGÐGÀAÐGÑGÔGÈÑKÔKÐKrA   c                 ój   — |dk     s||k    rt          d||fz  ¦  «        ‚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)Ú
IndexErrorrI   ©r7   r8   r>   rC   r9   s        r?   Údmp_integrate_inrR   t   sE   € ð  	ˆ1‚u€u��A’�ÝÐCÀqÈ!ÀfÑLÑMÔMÐMå˜Q  1 a¨¨AÑ.Ô.Ð.rA   c                 ó‚  — |dk    r| S t          | ¦  «        }||k     rg S g }|dk    r5| d| …         D ](}|                      ||¦  «        |z  ¦  «         |dz  }Œ)nU| d| …         D ]I}|}t          |dz
  ||z
  d¦  «        D ]}||z  }Œ|                      ||¦  «        |z  ¦  «         |dz  }ŒJt          |¦  «        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   r0   Néÿÿÿÿ)r   Úappendr4   r   )r7   r8   r9   r=   ÚderivÚcoeffÚkr;   s           r?   Údup_diffrY   Š   s  € ð  	ˆA‚v€vØˆå�1‰Œ€Aàˆ1‚u€uØˆ	à€EàˆA‚v€vØ�s˜˜�s”Vð 	ð 	ˆEØ�LŠL˜˜˜1™œ˜e™Ñ$Ô$Ð$Ø�‰FˆAˆAð	ð �s˜˜�s”Vð 	ð 	ˆEØˆAå˜1˜q™5 ! a¡%¨Ñ,Ô,ð ð �Ø�Q‘��à�LŠL˜˜˜1™œ˜e™Ñ$Ô$Ð$Ø�‰FˆAˆAå�UÑÔÐrA   c           	      ó  — |st          | ||¦  «        S |dk    r| S t          | |¦  «        }||k     rt          |¦  «        S g |dz
  }}|dk    rB| d| …         D ]5}|                     t	          | ||¦  «        ||¦  «        ¦  «         |dz  }Œ6nb| d| …         D ]V}|}t          |dz
  ||z
  d¦  «        D ]}	||	z  }Œ|                     t	          | ||¦  «        ||¦  «        ¦  «         |dz  }ŒWt          ||¦  «        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   r0   NrT   )rY   r   r$   rU   r   r4   r   )
r7   r8   rC   r9   r=   rV   rD   rW   rX   r;   s
             r?   Údmp_diffr[   µ   sH  € ð$ ð !Ý˜˜1˜aÑ Ô Ð ØˆA‚v€vØˆå�1�aÑÔ€Aàˆ1‚u€uÝ˜‰{Œ{Ðà�1�q‘5ˆ1€EàˆA‚v€vØ�s˜˜�s”Vð 	ð 	ˆEØ�LŠL�¨¨q¨q°©t¬t°Q¸Ñ:Ô:Ñ;Ô;Ð;Ø�‰FˆAˆAð	ð �s˜˜�s”Vð 	ð 	ˆEØˆAå˜1˜q™5 ! a¡%¨Ñ,Ô,ð ð �Ø�Q‘��à�LŠL�¨¨q¨q°©t¬t°Q¸Ñ:Ô:Ñ;Ô;Ð;Ø�‰FˆAˆAå�U˜AÑÔÐrA   c                 ó’   ‡‡‡‡‡— ‰‰k    rt          | ‰|‰¦  «        S |dz
  ‰dz   cŠŠt          ˆˆˆˆˆfd„| D ¦   «         |¦  «        S )z)Recursive helper for :func:`dmp_diff_in`.r0   c           
      ó8   •— g | ]}t          |‰‰‰‰‰¦  «        ‘ŒS rH   )Ú_rec_diff_inrJ   s     €€€€€r?   rM   z _rec_diff_in.<locals>.<listcomp>ë   ó+   ø€ ÐBÐBÐB¸!•| A q¨!¨Q°°1Ñ5Ô5ÐBÐBÐBrA   )r[   r   rN   s    ` ```@r?   r^   r^   ä   óh   øøøøø€ àˆA‚v€vÝ˜˜1˜a Ñ#Ô#Ð#àˆq‰5�!�a‘%€D€A€qåÐBÐBÐBÐBÐBÐBÐBÐB¸qÐBÑBÔBÀAÑFÔFÐFrA   c                 ól   — |dk     s||k    rt          d|›d|›�¦  «        ‚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 <= ú expected, got )rP   r^   rQ   s        r?   Údmp_diff_inrd   î   óH   € ð$ 	ˆ1‚u€u��A’�Ýˆj¸A¸A¸A¸q¸qÐAÑBÔBÐBå˜˜1˜a  A qÑ)Ô)Ð)rA   c                 ó|   — |s#|                      t          | |¦  «        ¦  «        S |j        }| D ]}||z  }||z  }Œ|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"   r1   )r7   Úar9   Úresultr<   s        r?   Údup_evalrj     sU   € ð ð 'Ø�yŠy�  1™œÑ&Ô&Ð&àŒV€Fàð ð ˆØ�!‰ˆØ�!‰ˆˆà€MrA   c                 óÜ   — |st          | ||¦  «        S |st          | |¦  «        S t          | |¦  «        |dz
  }}| dd…         D ]&}t          ||||¦  «        }t	          ||||¦  «        }Œ'|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

    r0   N)rj   r#   r    r   r   )r7   rh   rC   r9   ri   rD   rW   s          r?   Údmp_evalrl      s�   € ð ð !Ý˜˜1˜aÑ Ô Ð àð Ý�a˜‰|Œ|Ðå�q˜!‘”˜a !™eˆA€Fà�1�2�2”ð .ð .ˆÝ ¨¨1¨aÑ0Ô0ˆÝ˜ ¨¨1Ñ-Ô-ˆˆà€MrA   c                 ó’   ‡‡‡‡‡— ‰‰k    rt          | ‰‰‰¦  «        S ‰dz
  ‰dz   cŠŠt          ˆˆˆˆˆfd„| D ¦   «         ‰¦  «        S )z)Recursive helper for :func:`dmp_eval_in`.r0   c           
      ó8   •— g | ]}t          |‰‰‰‰‰¦  «        ‘ŒS rH   )Ú_rec_eval_in)rK   r<   r9   rh   r;   r>   rD   s     €€€€€r?   rM   z _rec_eval_in.<locals>.<listcomp>D  r_   rA   )rl   r   )r:   rh   rD   r;   r>   r9   s    `````r?   ro   ro   =  r`   rA   c                 ól   — |dk     s||k    rt          d|›d|›�¦  «        ‚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   rb   rc   )rP   ro   )r7   rh   r>   rC   r9   s        r?   Údmp_eval_inrq   G  re   rA   c                 óØ   ‡‡‡‡— ‰‰k    rt          | ‰d         ‰¦  «        S ˆˆˆˆfd„| D ¦   «         }‰‰t          ‰¦  «        z
  dz   k     r|S t          |‰‰ ‰z   dz
           ‰¦  «        S )z+Recursive helper for :func:`dmp_eval_tail`.rT   c           	      ó<   •— g | ]}t          |‰d z   ‰‰‰¦  «        ‘ŒS ©r0   )Ú_rec_eval_tail)rK   r<   ÚAr9   r;   rC   s     €€€€r?   rM   z"_rec_eval_tail.<locals>.<listcomp>d  s-   ø€ Ð<Ð<Ð<°A�n˜Q  A¡ q¨!¨QÑ/Ô/Ð<Ð<Ð<rA   r0   )rj   Úlen)r:   r;   rv   rC   r9   Úhs    ```` r?   ru   ru   _  s…   øøøø€ àˆA‚v€vÝ˜˜1˜Rœ5 !Ñ$Ô$Ð$à<Ð<Ð<Ð<Ð<Ð<Ð<¸Ð<Ñ<Ô<ˆàˆq•3�q‘6”6‰z˜A‰~ÒÐØˆHå˜A˜q !  a¡¨!¡œ}¨aÑ0Ô0Ð0rA   c                 óþ   — |s| S t          | |¦  «        rt          |t          |¦  «        z
  ¦  «        S t          | d|||¦  «        }|t          |¦  «        dz
  k    r|S t	          ||t          |¦  «        z
  ¦  «        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   r0   )r&   r$   rw   ru   r   )r7   rv   rC   r9   Úes        r?   Údmp_eval_tailr{   l  s‚   € ð$ ð Øˆå�!�QÑÔð $Ý˜�C ™FœF™
Ñ#Ô#Ð#å�q˜!˜Q  1Ñ%Ô%€Aà�C�‰FŒF�Q‰J‚€Øˆå˜˜A¥ A¡¤™JÑ'Ô'Ð'rA   c                 ó¶   ‡‡‡‡‡‡— ‰‰k    r"t          t          | ‰‰‰¦  «        ‰‰‰¦  «        S ‰dz
  ‰dz   cŠŠt          ˆˆˆˆˆˆfd„| D ¦   «         ‰¦  «        S )z+Recursive helper for :func:`dmp_diff_eval`.r0   c                 ó:   •— g | ]}t          |‰‰‰‰‰‰¦  «        ‘ŒS rH   )Ú_rec_diff_eval)rK   r<   r9   rh   r;   r>   r8   rD   s     €€€€€€r?   rM   z"_rec_diff_eval.<locals>.<listcomp>“  s-   ø€ ÐGÐGÐG¸q•~ a¨¨A¨q°!°Q¸Ñ:Ô:ÐGÐGÐGrA   )rl   r[   r   )r:   r8   rh   rD   r;   r>   r9   s    ``````r?   r~   r~   Œ  sz   øøøøøø€ àˆA‚v€vÝ�  A q¨!Ñ,Ô,¨a°°AÑ6Ô6Ð6àˆq‰5�!�a‘%€D€A€qåÐGÐGÐGÐGÐGÐGÐGÐGÐGÀAÐGÑGÔGÈÑKÔKÐKrA   c           	      ó°   — ||k    rt          d|›d|›d|›�¦  «        ‚|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 <= j < rc   r   )rP   rl   r[   r~   )r7   r8   rh   r>   rC   r9   s         r?   Údmp_diff_eval_inr�   –  sr   € ð$ 	ˆ1‚u€uÝˆj¸Q¸Q¸QÀÀÀÀ1À1ÐEÑFÔFÐFØð 7Ý�  A q¨!Ñ,Ô,¨a°°AÑ6Ô6Ð6å˜!˜Q  1 a¨¨AÑ.Ô.Ð.rA   c                 ó$  ‡‡‡— ‰j         rDg }| D ]>}|‰z  }|‰dz  k    r|                     |‰z
  ¦  «         Œ)|                     |¦  «         Œ?n4‰j        rt          ‰¦  «        Šˆˆfd„| D ¦   «         }nˆf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                 óF   •— g | ]} ‰t          |¦  «        ‰z  ¦  «        ‘ŒS rH   )Úint)rK   r<   r9   Úpis     €€r?   rM   zdup_trunc.<locals>.<listcomp>Ë  s+   ø€ Ð)Ð)Ð) ˆaˆa•�A‘”˜‘‰nŒnÐ)Ð)Ð)rA   c                 ó   •— g | ]}|‰z  ‘ŒS rH   rH   )rK   r<   Úps     €r?   rM   zdup_trunc.<locals>.<listcomp>Í  s   ø€ Ð Ð Ð ˜ˆa�!‰eÐ Ð Ð rA   )Úis_ZZrU   Úis_FiniteFieldr…   r   )r7   rˆ   r9   r:   r<   r†   s    ``  @r?   Ú	dup_truncr‹   °  sÁ   øøø€ ð 	„wð !Øˆàð 	ð 	ˆAØ�A‘ˆAà�1˜‘6ŠzˆzØ—’˜˜Q™‘”��à—’˜‘”��ð	ð 
Ô	ð !å�‰VŒVˆØ)Ð)Ð)Ð)Ð) aÐ)Ñ)Ô)ˆˆà Ð Ð Ð ˜QÐ Ñ Ô ˆå�Q‰<Œ<ÐrA   c                 óD   ‡‡‡— t          ˆˆˆf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 z
  ‰¦  «        ‘ŒS rt   )r   )rK   r<   r9   rˆ   rC   s     €€€r?   rM   zdmp_trunc.<locals>.<listcomp>ã  s+   ø€ Ð;Ð;Ð;°1•w˜q ! Q¨¡U¨AÑ.Ô.Ð;Ð;Ð;rA   )r   )r7   rˆ   rC   r9   s    ```r?   Ú	dmp_truncrŽ   Ò  s2   øøø€ õ" Ð;Ð;Ð;Ð;Ð;Ð;¸Ð;Ñ;Ô;¸QÑ?Ô?Ð?rA   c                 ót   ‡‡‡— |st          | ‰‰¦  «        S |dz
  Št          ˆˆˆf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

    r0   c                 ó4   •— g | ]}t          |‰‰‰¦  «        ‘ŒS rH   )Údmp_ground_trunc)rK   r<   r9   rˆ   rD   s     €€€r?   rM   z$dmp_ground_trunc.<locals>.<listcomp>û  s(   ø€ Ð@Ð@Ð@¸Õ'¨¨1¨a°Ñ3Ô3Ð@Ð@Ð@rA   )r‹   r   )r7   rˆ   rC   r9   rD   s    ` `@r?   r‘   r‘   æ  sU   øøø€ ð  ð "Ý˜˜A˜qÑ!Ô!Ð!à	ˆA‰€AåÐ@Ð@Ð@Ð@Ð@Ð@¸QÐ@Ñ@Ô@À!ÑDÔDÐDrA   c                 óz   — | 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   )r7   r9   Úlcs      r?   Ú	dup_monicr•   þ  sG   € ð$ ð Øˆå	��1‰Œ€Bà‡x‚x��|„|ð *Øˆå  2 qÑ)Ô)Ð)rA   c                 ó¾   — |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   )r7   rC   r9   r”   s       r?   Údmp_ground_monicr—     sm   € ð, ð Ý˜˜A‰ŒÐå�!�QÑÔð Øˆå	�q˜!˜QÑ	Ô	€Bà‡x‚x��|„|ð -Øˆå  2 q¨!Ñ,Ô,Ð,rA   c                 óÚ   — ddl m} | s|j        S |j        }||k    r| D ]}|                     ||¦  «        }Œn2| D ]/}|                     ||¦  «        }|                     |¦  «        r nŒ0|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š   r1   Úgcdr“   )r7   r9   rš   Úcontr<   s        r?   Údup_contentrž   ?  s¡   € ð, 'Ð&Ð&Ð&Ð&Ð&àð ØŒvˆàŒ6€DàˆB‚w€wØð 	"ð 	"ˆAØ—5’5˜˜q‘>”>ˆDˆDð	"ð ð 	ð 	ˆAØ—5’5˜˜q‘>”>ˆDà�xŠx˜‰~Œ~ð Ø�ðð €KrA   c           	      ó`  — ddl m} |st          | |¦  «        S t          | |¦  «        r|j        S |j        |dz
  }}||k    r+| D ]'}|                     |t          |||¦  «        ¦  «        }Œ(nA| D ]>}|                     |t          |||¦  «        ¦  «        }|                     |¦  «        r nŒ?|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™   r0   )r›   rš   rž   r&   r1   rœ   Údmp_ground_contentr“   )r7   rC   r9   rš   r�   rD   r<   s          r?   r    r    i  sé   € ð, 'Ð&Ð&Ð&Ð&Ð&àð !Ý˜1˜aÑ Ô Ð å�!�QÑÔð ØŒvˆàŒf�a˜!‘eˆ!€DàˆB‚w€wØð 	<ð 	<ˆAØ—5’5˜Õ1°!°Q¸Ñ:Ô:Ñ;Ô;ˆDˆDð	<ð ð 	ð 	ˆAØ—5’5˜Õ1°!°Q¸Ñ:Ô:Ñ;Ô;ˆDà�xŠx˜‰~Œ~ð Ø�ðð €KrA   c                 ó�   — | 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)

    )r1   rž   r“   r   )r7   r9   r�   s      r?   Údup_primitiver¢   –  sY   € ð, ð ØŒv�qˆyÐå�q˜!ÑÔ€Dà‡x‚x��~„~ð 0Ø�Qˆwˆà•^ A t¨QÑ/Ô/Ð/Ð/rA   c                 óÔ   — |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&   r1   r    r“   r   )r7   rC   r9   r�   s       r?   Údmp_ground_primitiver¤   ·  s   € ð, ð #Ý˜Q Ñ"Ô"Ð"å�!�QÑÔð ØŒv�qˆyÐå˜a  AÑ&Ô&€Dà‡x‚x��~„~ð 3Ø�Qˆwˆà•^ A t¨Q°Ñ2Ô2Ð2Ð2rA   c                 óæ   — 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   )r7   r:   r9   ÚfcÚgcrœ   s         r?   Údup_extractr¨   Û  ss   € õ 
�Q˜Ñ	Ô	€BÝ	�Q˜Ñ	Ô	€Bà
�%Š%��B‰-Œ-€Cà�8Š8�C‰=Œ=ð &Ý˜1˜c 1Ñ%Ô%ˆÝ˜1˜c 1Ñ%Ô%ˆà��1ˆ9ÐrA   c                 óî   — 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   )r7   r:   rC   r9   r¦   r§   rœ   s          r?   Údmp_ground_extractrª   õ  s{   € õ 
˜A˜q !Ñ	$Ô	$€BÝ	˜A˜q !Ñ	$Ô	$€Bà
�%Š%��B‰-Œ-€Cà�8Š8�C‰=Œ=ð )Ý˜1˜c 1 aÑ(Ô(ˆÝ˜1˜c 1 aÑ(Ô(ˆà��1ˆ9ÐrA   c                 ó~  — |j         s|j        st          d|z  ¦  «        ‚t          d¦  «        }t          d¦  «        }| s||fS |j        |j        gg|j        gg gg}t          | d         d¦  «        }| dd…         D ]5}t          ||d|¦  «        }t          |t          |d¦  «        dd|¦  «        }Œ6t          |¦  «        }| 
                    ¦   «         D ]c\  }}|dz  }	|	st          ||d|¦  «        }Œ|	dk    rt          ||d|¦  «        }Œ8|	dk    rt          ||d|¦  «        }ŒQt          ||d|¦  «        }Œd||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 %sr0   r   rƒ   Né   )r‰   Úis_QQr+   r$   Úoner1   r%   r   r   r'   Úitemsr   r	   )
r7   r9   Úf1Úf2r:   rx   r<   ÚHrX   r8   s
             r?   Údup_real_imagr³     sx  € ð& Œ7ð ]˜1œ7ð ]ÝÐWÐZ[Ñ[Ñ\Ô\Ð\å	�!‰Œ€BÝ	�!‰Œ€Bàð Ø�2ˆvˆàŒ5�!”&ˆ/Ð	˜aœe˜W b˜MÐ*€AÝ�1�Q”4˜ÑÔ€AàˆqˆrˆrŒUð 7ð 7ˆÝ�A�q˜!˜QÑÔˆÝ˜�J q¨!Ñ,Ô,¨a°°AÑ6Ô6ˆˆå˜ÑÔ€Aà—’‘	”	ð 
&ð 
&‰ˆˆ1Ø�‰Eˆàð 	&Ý˜˜Q  1Ñ%Ô%ˆBˆBØ�!ŠVˆVÝ˜˜Q  1Ñ%Ô%ˆBˆBØ�!ŠVˆVÝ˜˜Q  1Ñ%Ô%ˆBˆBå˜˜Q  1Ñ%Ô%ˆBˆBàˆrˆ6€MrA   c                 ó„   — t          | ¦  «        } t          t          | ¦  «        dz
  dd¦  «        D ]}| |          | |<   Œ| 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

    rƒ   rT   éþÿÿÿ)Úlistr4   rw   )r7   r9   r;   s      r?   Ú
dup_mirrorr·   C  sJ   € õ 	ˆQ‰Œ€Aå•3�q‘6”6˜A‘:˜r 2Ñ&Ô&ð ð ˆØ�!”ˆuˆˆ!‰ˆà€HrA   c                 ó¢   — t          | ¦  «        t          | ¦  «        dz
  |}}} t          |dz
  dd¦  «        D ]}|| |         z  ||z  c| |<   }Œ| 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

    r0   rT   ©r¶   rw   r4   )r7   rh   r9   r=   Úbr;   s         r?   Ú	dup_scaler»   Y  sb   € õ �1‰gŒg•s˜1‘v”v ‘z 1ˆ!€q€Aå�1�q‘5˜"˜bÑ!Ô!ð ð ˆØ�A�a”D‘&˜!˜A™#ˆˆˆ!‰ˆaˆaà€HrA   c                 óÎ   — t          | ¦  «        t          | ¦  «        dz
  }} t          |dd¦  «        D ]1}t          d|¦  «        D ]}| |dz   xx         || |         z  z  cc<   ŒŒ2| 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

    r0   r   rT   r¹   )r7   rh   r9   r=   r;   r>   s         r?   Ú	dup_shiftr½   o  s}   € õ �‰7Œ7•C˜‘F”F˜Q‘J€q€Aå�1�a˜‰_Œ_ð ð ˆÝ�q˜!‘”ð 	ð 	ˆAØˆa�!‰eˆHˆHŒH˜˜!˜Aœ$™ÑˆHˆH‰HˆHð	ð €HrA   c                 ó˜  ‡‡‡	— ‰st          | |d         ‰¦  «        S t          | ‰¦  «        r| S |d         |dd…         c}Š	ˆˆ	ˆfd„| D ¦   «         } t          | ¦  «        dz
  }t          |dd¦  «        D ]T}t          d|¦  «        D ]A}t	          | |         |‰dz
  ‰¦  «        }t          | |dz            |‰dz
  ‰¦  «        | |dz   <   ŒBŒU| 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   r0   Nc                 ó:   •— g | ]}t          |‰‰d z
  ‰¦  «        ‘ŒS rt   )Ú	dmp_shift)rK   r<   r9   Úa1rC   s     €€€r?   rM   zdmp_shift.<locals>.<listcomp>¡  s+   ø€ Ð/Ð/Ð/ q�)�A�r˜1˜Q™3 Ñ
"Ô
"Ð/Ð/Ð/rA   rT   )r½   r&   rw   r4   r   r   )
r7   rh   rC   r9   Úa0r=   r;   r>   ÚafjrÁ   s
     ``     @r?   rÀ   rÀ   †  s  øøø€ ð& ð %Ý˜˜A˜aœD !Ñ$Ô$Ð$å�!�QÑÔð ØˆàˆqŒT�1�Q�R�R”5€F€Bˆà/Ð/Ð/Ð/Ð/Ð/¨AÐ/Ñ/Ô/€AÝˆA‰Œ�‰
€Aå�1�a˜‰_Œ_ð 6ð 6ˆÝ�q˜!‘”ð 	6ð 	6ˆAÝ   1¤ r¨1¨Q©3°Ñ2Ô2ˆCÝ˜q  Q¡œx¨¨a°©c°1Ñ5Ô5ˆAˆa�!‰e‰HˆHð	6ð €HrA   c                 ó‚  — | sg S t          | ¦  «        dz
  }| d         g|j        gg}}t          d|¦  «        D ],}|                     t	          |d         ||¦  «        ¦  «         Œ-t          | dd…         |dd…         ¦  «        D ]8\  }}t	          |||¦  «        }t          |||¦  «        }t          |||¦  «        }Œ9|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

    r0   r   rT   N)rw   r®   r4   rU   r
   Úzipr   r   )	r7   rˆ   Úqr9   r=   rx   ÚQr;   r<   s	            r?   Údup_transformrÈ   ¬  sØ   € ð ð Øˆ	åˆA‰Œ�‰
€AØˆaŒDˆ6�Q”U�G�9€q€Aå�1�a‰[Œ[ð 'ð 'ˆØ	�Š•˜˜2œ  1Ñ%Ô%Ñ&Ô&Ð&Ð&å�A�a�b�b”E˜1˜Q˜R˜Rœ5Ñ!Ô!ð ð ‰ˆˆ1Ý�A�q˜!ÑÔˆÝ˜1˜a Ñ#Ô#ˆÝ�A�q˜!ÑÔˆˆà€HrA   c           	      ó   — t          |¦  «        dk    r-t          t          | t          ||¦  «        |¦  «        g¦  «        S | sg S | d         g}| dd…         D ]%}t	          |||¦  «        }t          ||d|¦  «        }Œ&|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

    r0   r   N)rw   r   rj   r   r
   r   )r7   r:   r9   rx   r<   s        r?   Údup_composerÊ   Ë  s’   € õ ˆ1�v„v�‚{€{Ý�( 1¥f¨Q°¡l¤l°AÑ6Ô6Ð7Ñ8Ô8Ð8àð Øˆ	à	
ˆ1Œˆ€AàˆqˆrˆrŒUð %ð %ˆÝ�A�q˜!ÑÔˆÝ˜˜A˜q !Ñ$Ô$ˆˆà€HrA   c                 óÆ   — |st          | ||¦  «        S t          | |¦  «        r| S | d         g}| dd…         D ]'}t          ||||¦  «        }t          ||d||¦  «        }Œ(|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   r0   N)rÊ   r&   r   r   )r7   r:   rC   r9   rx   r<   s         r?   Údmp_composerÌ   è  s†   € ð ð $Ý˜1˜a Ñ#Ô#Ð#å�!�QÑÔð Øˆà	
ˆ1Œˆ€AàˆqˆrˆrŒUð (ð (ˆÝ�A�q˜!˜QÑÔˆÝ˜˜A˜q ! QÑ'Ô'ˆˆà€HrA   c                 ó¸  — t          | ¦  «        dz
  }t          | |¦  «        }t          | ¦  «        } ||j        i}||z  }t	          d|¦  «        D ]{}|j        }t	          d|¦  «        D ]?}	||	z   |z
  | vrŒ||	z
  |vrŒ| ||	z   |z
           |||	z
           }}
||||	z  z
  |
z  |z  z  }Œ@|                     |||z  |z  ¦  «        |||z
  <   Œ|t          ||¦  «        S )ú+Helper function for :func:`_dup_decompose`.r0   r   )rw   r   r'   r®   r4   r1   Úquor(   )r7   Úsr9   r=   r”   r:   Úrr;   rW   r>   r¦   r§   s               r?   Ú_dup_right_decomposerÒ     s  € åˆA‰Œ�‰
€AÝ	��1‰Œ€Bå˜ÑÔ€AØ
ˆQŒUˆ€Aà	ˆQ‰€Aå�1�a‰[Œ[ð (ð (ˆØ”ˆå�q˜!‘”ð 	%ð 	%ˆAØ�q‘5˜1‘9 �>�>Øà�q‘5˜A�:�:Øà�q˜1‘u˜q‘y”\ 1 Q¨¡U¤8�ˆBØ�a˜!˜A™#‘g˜r‘\ "‘_Ñ$ˆEˆEà—5’5˜  !¡ B¡Ñ'Ô'ˆˆ!ˆa‰%‰ˆå˜Q Ñ"Ô"Ð"rA   c                 ó¸   — i d}}| rEt          | ||¦  «        \  }}t          |¦  «        dk    rdS t          ||¦  «        ||<   ||dz   }} | °Et          ||¦  «        S )rÎ   r   Nr0   )r   r   r   r(   )r7   rx   r9   r:   r;   rÆ   rÑ   s          r?   Ú_dup_left_decomposerÔ   !  sx   € àˆq€q€Aà
ð Ý�q˜!˜QÑÔ‰ˆˆ1å�a‰=Œ=˜1ÒÐØ�4å˜!˜Q‘<”<ˆAˆa‰DØ�a˜!‘eˆqˆAð ð õ ˜Q Ñ"Ô"Ð"rA   c                 ó¼   — t          | ¦  «        dz
  }t          d|¦  «        D ]8}||z  dk    rŒt          | ||¦  «        }|�t          | ||¦  «        }|�||fc S Œ9dS )z*Helper function for :func:`dup_decompose`.r0   rƒ   r   N)rw   r4   rÒ   rÔ   )r7   r9   ÚdfrÐ   rx   r:   s         r?   Ú_dup_decomposer×   1  sw   € å	ˆQ‰Œ�!‰€Bå�1�b‰\Œ\ð 
ð 
ˆØ�‰6�QŠ;ˆ;Øå   A qÑ)Ô)ˆàˆ=Ý# A q¨!Ñ,Ô,ˆAàˆ}Ø˜!�t���øàˆ4rA   c                 óT   — g }	 t          | |¦  «        }|�|\  } }|g|z   }nnŒ | g|z   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]_

    )r×   )r7   r9   ÚFri   rx   s        r?   Údup_decomposerÚ   D  sO   € ðH 	€AðÝ  1Ñ%Ô%ˆàÐØ‰DˆAˆqØ��a‘ˆAˆAàðð ˆ3�‰7€NrA   c                 ón  — |j         r(|                     ¦   «         }t          | |||¦  «        } |}|j        st	          d¦  «        ‚t          | |¦  «        g g }}}|                     ¦   «         D ]!\  }}|j        s|                     |¦  «         Œ"t          ddgt          |¦  «        d¬¦  «        }	|	D ]]}
t          |¦  «        }t          |
|¦  «        D ]\  }}|dk    r||          ||<   Œ|                     t          |||¦  «        ¦  «         Œ^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 domainrT   r0   T)Ú
repetition)Úis_GaussianFieldÚas_AlgebraicFieldr   Úis_Algebraicr+   r   r¯   Ú	is_groundrU   r,   rw   ÚdictrÅ   r   r   Údom)r7   rC   r9   ÚK1rÙ   ÚmonomsÚpolysÚmonomrW   ÚpermsÚpermÚGÚsigns                r?   Údmp_liftrë   v  s]  € ð& 	Ôð Ø× Ò Ñ"Ô"ˆÝ˜˜1˜a Ñ$Ô$ˆØˆàŒ>ð CÝØAñCô Cð 	Cõ # 1 aÑ(Ô(¨"¨bˆu€v€AàŸš™	œ	ð !ð !‰ˆˆuØŒð 	!Ø�MŠM˜%Ñ Ô Ð øå˜˜A�w¥ F¡¤¸Ð=Ñ=Ô=€Eàð -ð -ˆÝ�‰GŒGˆå˜t VÑ,Ô,ð 	%ð 	%‰KˆD�%Ø�rŠzˆzØ˜eœH˜9��%‘øà�Š•] 1 a¨Ñ+Ô+Ñ,Ô,Ð,Ð,å•z %¨¨AÑ.Ô.°°1°a´eÑ<Ô<Ð<rA   c                 ód   — |j         d}}| D ]#}|                     ||z  ¦  «        r|dz  }|r|}Œ$|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   r0   )r1   Úis_negative)r7   r9   ÚprevrX   rW   s        r?   Údup_sign_variationsrï   ¦  sR   € ð Œf�aˆ!€Dàð ð ˆØ�=Š=˜˜t™Ñ$Ô$ð 	Ø�‰FˆAàð 	ØˆDøà€HrA   NFc                 ó`  ‡‡‡— ‰€‰j         r‰                     ¦   «         Šn‰Š‰j        Š| D ]+}‰                     ‰‰                     |¦  «        ¦  «        ŠŒ,‰                     ‰¦  «        r|s‰| fS ‰t          | ‰‰¦  «        fS ˆˆˆfd„| D ¦   «         } |s‰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           	      óŽ   •— g | ]A}‰                      |¦  «        ‰                     ‰‰                     |¦  «        ¦  «        z  ‘ŒBS rH   )ÚnumerrÏ   Údenom)rK   r<   ÚK0rã   Úcommons     €€€r?   rM   z$dup_clear_denoms.<locals>.<listcomp>å  s@   ø€ Ð<Ð<Ð<°Qˆ�Š�!‰Œ�R—V’V˜F B§H¢H¨Q¡K¤KÑ0Ô0Ñ	0Ð<Ð<Ð<rA   )Úhas_assoc_RingÚget_ringr®   Úlcmró   r“   r   )r7   rô   rã   rg   r<   rõ   s    ``  @r?   Údup_clear_denomsrù   À  sç   øøø€ ð$ 
€zØÔð 	Ø—’‘”ˆBˆBàˆBàŒV€Fàð -ð -ˆØ—’˜ §¢¨¡¤Ñ,Ô,ˆˆà	‡y‚y�ÑÔð 2Øð 	2Ø˜1�9Ðà�; q¨"¨bÑ1Ô1Ð1Ð1ð 	=Ð<Ð<Ð<Ð<Ð<¸!Ð<Ñ<Ô<€Aàð Ø•{ 1 b¨"Ñ-Ô-Ð-Ð-à�qˆyÐrA   c           
      óÖ   — |j         }|s/| D ]+}|                     ||                     |¦  «        ¦  «        }Œ,n0|dz
  }| D ](}|                     |t          ||||¦  «        ¦  «        }Œ)|S )z.Recursive helper for :func:`dmp_clear_denoms`.r0   )r®   rø   ró   Ú_rec_clear_denoms)r:   rD   rô   rã   rõ   r<   rL   s          r?   rû   rû   í  sŠ   € àŒV€Fàð EØð 	1ð 	1ˆAØ—V’V˜F B§H¢H¨Q¡K¤KÑ0Ô0ˆFˆFð	1ð �‰Eˆàð 	Eð 	EˆAØ—V’V˜FÕ$5°a¸¸BÀÑ$CÔ$CÑDÔDˆFˆFà€MrA   c                 ó  — |st          | |||¬¦  «        S |€|j        r|                     ¦   «         }n|}t          | |||¦  «        }|                     |¦  «        st          | |||¦  «        } |s|| 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)

    )rg   )rù   rö   r÷   rû   r“   r   r   )r7   rC   rô   rã   rg   rõ   s         r?   Údmp_clear_denomsrý   ý  s¬   € ð$ ð <Ý  2 r°7Ð;Ñ;Ô;Ð;à	€zØÔð 	Ø—’‘”ˆBˆBàˆBå˜q ! R¨Ñ,Ô,€Fà�9Š9�VÑÔð -Ý˜1˜f a¨Ñ,Ô,ˆàð 1Ø�qˆyÐà•{ 1 a¨¨RÑ0Ô0Ð0Ð0rA   c                 óâ  — |                      t          | |¦  «        ¦  «        g}|j        |j        |j        g}t	          t          t          |¦  «        ¦  «        ¦  «        }t          d|dz   ¦  «        D ]y}t          | |d¦  «        |¦  «        }t          | t          ||¦  «        |¦  «        }t          t          |||¦  «        ||¦  «        }t          |t          |¦  «        |¦  «        }Œz|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

    r0   rƒ   )Úrevertr"   r®   r1   r…   Ú_ceilÚ_log2r4   r   r
   r   r   r   r   r   )	r7   r=   r9   r:   rx   ÚNr;   rh   rº   s	            r?   Ú
dup_revertr  #  sÓ   € ð( 
�Š•&˜˜A‘,”,Ñ	Ô	Ð €AØ	
Œ�”˜œÐ€Aå�E•%˜‘(”(‰OŒOÑÔ€Aå�1�a˜!‘e‰_Œ_ð ,ð ,ˆÝ˜1˜a˜a ™dœd AÑ&Ô&ˆÝ�A•w˜q !‘}”} aÑ(Ô(ˆÝ•G˜A˜q !Ñ$Ô$ a¨Ñ+Ô+ˆÝ�q�* Q™-œ-¨Ñ+Ô+ˆˆà€HrA   c                 óH   — |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*   )r7   r:   rC   r9   s       r?   Ú
dmp_revertr  E  s.   € ð ð 0Ý˜!˜Q Ñ"Ô"Ð"å)¨!¨QÑ/Ô/Ð/rA   )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@   rE   rI   rR   rY   r[   r^   rd   rj   rl   ro   rq   ru   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  rH   rA   r?   ú<module>r     s÷  ðØ NÐ Nðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð 'Ð &Ð &Ð &Ð &Ð &à -Ð -Ð -Ð -Ð -Ð -Ð -Ð -ðð ð ð@ ð  ð  ðFLð Lð Lð/ð /ð /ð,(ð (ð (ðV,ð ,ð ,ð^Gð Gð Gð*ð *ð *ð0ð ð ð4ð ð ð:Gð Gð Gð*ð *ð *ð0
1ð 
1ð 
1ð(ð (ð (ð@Lð Lð Lð/ð /ð /ð4ð ð ðD@ð @ð @ð(Eð Eð Eð0*ð *ð *ð:!-ð !-ð !-ðH'ð 'ð 'ðT*ð *ð *ðZ0ð 0ð 0ðB!3ð !3ð !3ðHð ð ð4ð ð ð41ð 1ð 1ðhð ð ð,ð ð ð,ð ð ð.#ð #ð #ðLð ð ð>ð ð ð:ð ð ð:#ð #ð #ð8#ð #ð #ð ð ð ð&/ð /ð /ðd-=ð -=ð -=ð`ð ð ð4*ð *ð *ð *ðZð ð ð #1ð #1ð #1ð #1ðLð ð ðD0ð 0ð 0ð 0ð 0rA   