+
    ‹°³j2t  ã                   ó  € R t ^ RIHtHtHtHtHtHtHtH	t	H
t
HtHtHtHtHtHtHtHtHtHt ^ RIHtHtHtHtHtHtHtHtHtHtH t H!t!H"t"H#t#H$t$H%t%H&t&H't'H(t(H)t) ^ RI*H+t+H,t, ^ RI-H.t/H0t1 R t2R t3R t4R t5R	 t6R
 t7R t8R t9R t:R t;R t<R t=R t>R t?R t@R tAR tBR tCR tDR tER tFR tGR tHR tIR tJR tKR tLR  tMR! tNR" tOR# tPR$ tQR% tRR& tSR' tTR( tUR) tVR* tWR+ tXR, tYR- tZR. t[R/ t\R0 t]R7R2 lt^R3 t_R7R4 lt`R5 taR6 tbR1# )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Ú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           
     ó<  € V^ 8:  g	   V '       g   V # VP                   .V,          p\        \        V 4      4       F^  w  rEV^,           p\        ^V4       F  pWdV,           ^,           ,          pK  	  VP	                  ^ VP                  WR! V4      4      4       K`  	  V# )z÷
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

)ÚzeroÚ	enumerateÚreversedÚrangeÚinsertÚexquo)ÚfÚmÚKÚgÚiÚcÚnÚjs   &&&     ÚW/home/luca/screen-checking/.venv/lib/python3.14/site-packages/sympy/polys/densetools.pyÚdup_integrater=   '   s„   € ð  	ˆA„v—QØˆà	
�‰ˆ��
€Aäœ( 1›+Ö&‰ˆØ��Eˆä�q˜!–ˆAØ�Q•˜•�NŠAñ ð 	
�‰��A—G‘G˜A˜q ›tÓ$Ö%ñ 'ð €Hó    c           
     óz  € V'       g   \        WV4      # V^ 8:  g   \        W4      '       d   V # \        W^,
          V4      V^,
          rT\        \	        V 4      4       FY  w  rgV^,           p\        ^V4       F  p	W†V	,           ^,           ,          pK  	  VP                  ^ \        Ws! V4      WS4      4       K[  	  V# )zþ
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/   r0   r1   r2   r   )
r4   r5   Úur6   r7   Úvr8   r9   r:   r;   s
   &&&&      r<   Údmp_integraterB   G   s¡   € ÷  Ü˜Q 1Ó%Ð%àˆA„v”˜A×!Ò!Øˆä�Q˜A�˜qÓ! 1 q¥5€qäœ( 1›+Ö&‰ˆØ��Eˆä�q˜!–ˆAØ�Q•˜•�NŠAñ ð 	
�‰�”N 1 a¨£d¨AÓ1Ö2ñ 'ð €Hr>   c                ó    € W48X  d   \        WW%4      # V^,
          V^,           r6\        V  Uu. uF  p\        WqWcWE4      NK  	  upV4      # u upi )z.Recursive helper for :func:`dmp_integrate_in`.)rB   r   Ú_rec_integrate_in©r7   r5   rA   r8   r;   r6   Úwr9   s   &&&&&&  r<   rD   rD   j   sL   € à„vÜ˜Q 1Ó(Ð(àˆq�5�!�a•%€qäÁAÓGÁA¸qÔ(¨¨q°QÖ:ÁAÑGÈÓKÐKùÒGó   ­Ac                ó^   € V^ 8  g   W#8”  d   \        RW23,          4      h\        WV^ W$4      # )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

z(0 <= j <= u expected, got u = %d, j = %d)Ú
IndexErrorrD   ©r4   r5   r;   r@   r6   s   &&&&&r<   Údmp_integrate_inrK   t   s3   € ð  	ˆ1„u�”ÜÐCÀqÀfÕLÓMÐMä˜Q 1 a¨Ó.Ð.r>   c                óŠ  € V^ 8:  d   V # \        V 4      pW18  d   . # . pV^8X  d6   V RV)   F*  pVP                  V! V4      V,          4       V^,          pK,  	  M_V RV)   FU  pTp\        V^,
          W1,
          R4       F  pWg,          pK  	  VP                  V! V4      V,          4       V^,          pKW  	  \        V4      # )zû
``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

Néÿÿÿÿ)r   Úappendr1   r   )r4   r5   r6   r:   ÚderivÚcoeffÚkr8   s   &&&     r<   Údup_diffrR   Š   sÃ   € ð  	ˆA„vØˆä�1‹€Aà„uØˆ	à€EàˆA„vØ�s˜˜“VˆEØ�L‰L™˜1›˜e�Ô$Ø��FŠAò ð �s˜˜“VˆEØˆAä˜1˜q�5 !¥%¨Ö,�Ø•’ñ -ð �L‰L™˜1›˜e�Ô$Ø��FŠAñ ô �UÓÐr>   c           	     óà  € V'       g   \        WV4      # V^ 8:  d   V # \        W4      pWA8  d   \        V4      # . V^,
          reV^8X  d9   V RV)   F-  pVP                  \	        Ws! V4      Wc4      4       V^,          pK/  	  MbV RV)   FX  pTp\        V^,
          WA,
          R4       F  p	W‰,          pK  	  VP                  \	        Ws! V4      Wc4      4       V^,          pKZ  	  \        WR4      # )a  
``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

NrM   )rR   r   r"   rN   r   r1   r   )
r4   r5   r@   r6   r:   rO   rA   rP   rQ   r8   s
   &&&&      r<   Údmp_diffrT   µ   sé   € ÷$ Ü˜˜aÓ Ð ØˆA„vØˆä�1Ó€Aà„uÜ˜‹{Ðà�1�q•5ˆ1àˆA„vØ�s˜˜“VˆEØ�L‰Lœ¨¨q°«t°QÓ:Ô;Ø��FŠAò ð �s˜˜“VˆEØˆAä˜1˜q�5 !¥%¨Ö,�Ø•’ñ -ð �L‰Lœ¨¨q°«t°QÓ:Ô;Ø��FŠAñ ô �UÓÐr>   c                ó    € W48X  d   \        WW%4      # V^,
          V^,           r6\        V  Uu. uF  p\        WqWcWE4      NK  	  upV4      # u upi )z)Recursive helper for :func:`dmp_diff_in`.)rT   r   Ú_rec_diff_inrE   s   &&&&&&  r<   rV   rV   ä   óK   € à„vÜ˜˜aÓ#Ð#àˆq�5�!�a•%€qä¹qÓB¹q¸!”| A¨!°Ö5¹qÑBÀAÓFÐFùÒBrG   c                ó^   € V^ 8  g   W#8”  d   \        RV: RV: 24      h\        WV^ W$4      # )a'  
``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

ú
0 <= j <= ú expected, got )rI   rV   rJ   s   &&&&&r<   Údmp_diff_inr[   î   ó0   € ð$ 	ˆ1„u�”Ý»AºqÐAÓBÐBä˜˜a  AÓ)Ð)r>   c                ó”   € V'       g   VP                  \        W4      4      # VP                  pV  F  pW1,          pW4,          pK  	  V# )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.   )r4   Úar6   Úresultr9   s   &&&  r<   Údup_evalra     sB   € ÷ Ø�y‰yœ ›Ó&Ð&à�V‰V€FãˆØ�ˆØ�Šñ ð €Mr>   c                óÊ   € V'       g   \        WV4      # V'       g   \        W4      # \        W4      V^,
          rTV R,           F  p\        WAWS4      p\	        WFWS4      pK  	  V# )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

ºé   NN)ra   r!   r   r   r   )r4   r_   r@   r6   r`   rA   rP   s   &&&&   r<   Údmp_evalre      s_   € ÷ Ü˜˜aÓ Ð çÜ�a‹|Ðä�q“˜a !�eˆAà�2—�ˆÜ ¨1Ó0ˆÜ˜¨Ó-Šñ ð €Mr>   c                ó    € W48X  d   \        WW%4      # V^,
          V^,           r2\        V  Uu. uF  p\        WaW#WE4      NK  	  upV4      # u upi )z)Recursive helper for :func:`dmp_eval_in`.)re   r   Ú_rec_eval_in)r7   r_   rA   r8   r;   r6   r9   s   &&&&&& r<   rg   rg   =  rW   rG   c                ó^   € V^ 8  g   W#8”  d   \        RV: RV: 24      h\        WV^ W$4      # )a  
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

rY   rZ   )rI   rg   )r4   r_   r;   r@   r6   s   &&&&&r<   Údmp_eval_inri   G  r\   r>   c           
     ó  € W8X  d   \        WR,          V4      # V  Uu. uF  p\        WQ^,           W#V4      NK  	  ppW\        V4      ,
          ^,           8  d   V# \        WbV) V,           ^,
          ,          V4      # u upi )z+Recursive helper for :func:`dmp_eval_tail`.rM   )ra   Ú_rec_eval_tailÚlen)r7   r8   ÚAr@   r6   r9   Úhs   &&&&&  r<   rk   rk   _  sp   € à„vÜ˜˜R�5 !Ó$Ð$á9:Ó<¹°AŒn˜Q A¥ q¨QÖ/¹ˆÐ<à”3�q“6�z˜A�~ÔØˆHä˜A !  a¥¨!¥�}¨aÓ0Ð0ùò =s   žA>c                óò   € V'       g   V # \        W4      '       d   \        V\        V4      ,
          4      # \        V ^ WV4      pV\        V4      ^,
          8X  d   V# \	        WB\        V4      ,
          4      # )zõ
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"   rl   rk   r   )r4   rm   r@   r6   Úes   &&&& r<   Údmp_eval_tailrq   l  sa   € ÷$ Øˆä�!×ÒÜ˜œC ›F�
Ó#Ð#ä�q˜!˜Q 1Ó%€AàŒC�‹F�Q�J„Øˆä˜¤ A£�JÓ'Ð'r>   c                ó¸   € WE8X  d   \        \        WW64      W#V4      # V^,
          V^,           rC\        V  Uu. uF  p\        WqW#WEV4      NK  	  upV4      # u upi )z+Recursive helper for :func:`dmp_diff_eval`.)re   rT   r   Ú_rec_diff_eval)r7   r5   r_   rA   r8   r;   r6   r9   s   &&&&&&& r<   rs   rs   Œ  sV   € à„vÜœ  qÓ,¨a°AÓ6Ð6àˆq�5�!�a•%€qäÁAÓGÁA¸q”~ a¨A°!¸Ö:ÁAÑGÈÓKÐKùÒGs   ¸Ac           	     ó–   € W48”  d   \        RV: RV: RV: 24      hV'       g   \        \        WWE4      W$V4      # \        WW$^ W54      # )a1  
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 < rZ   )rI   re   rT   rs   )r4   r5   r_   r;   r@   r6   s   &&&&&&r<   Údmp_diff_eval_inrv   –  sE   € ð$ 	„uÝ»QÃÂ1ÐEÓFÐFßÜœ  qÓ,¨a°AÓ6Ð6ä˜!  a¨Ó.Ð.r>   c                óœ  € VP                   '       dL   . pV  FB  pWA,          pWA^,          8”  d   VP                  WA,
          4       K1  VP                  V4       KD  	  M[VP                  '       d3   \        V4      pV  Uu. uF  qB! \        V4      V,          4      NK  	  ppMV  Uu. uF  qDV,          NK  	  pp\	        V4      # u upi u upi )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

)Úis_ZZrN   Úis_FiniteFieldÚintr   )r4   Úpr6   r7   r9   Úpis   &&&   r<   Ú	dup_truncr}   °  s§   € ð 	‡w‡w€wØˆãˆAØ•ˆAà˜•6ŒzØ—‘˜�–à—‘˜–ò ð 
×	×	Ð	ä�‹VˆÙ&'Ó)¡a ˆa”�A“˜•Žn¡aˆÐ)ˆáÓ ™Q˜�!�eˆe™QˆÐ ä�Q‹<Ðùò	 *ùâ s   Á? CÂ&C	c                óh   € \        V  Uu. uF  p\        WAV^,
          V4      NK  	  upV4      # u upi )a  
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

)r   r   )r4   r{   r@   r6   r9   s   &&&& r<   Ú	dmp_truncr   Ò  s0   € ô" ¹Ó;¹°1”w˜q Q¨¥U¨AÖ.¹Ñ;¸QÓ?Ð?ùÒ;s   Š/c                ó’   € V'       g   \        WV4      # V^,
          p\        V  Uu. uF  p\        WQWC4      NK  	  upV4      # u upi )zü
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}   r   Údmp_ground_trunc)r4   r{   r@   r6   rA   r9   s   &&&&  r<   r�   r�   æ  sD   € ÷  Ü˜˜qÓ!Ð!à	ˆA�€Aä¹QÓ@¹Q¸Ô'¨¨aÖ3¹QÑ@À!ÓDÐDùÒ@s   §Ac                óv   € V '       g   V # \        W4      pVP                  V4      '       d   V # \        WV4      # )a  
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   )r4   r6   Úlcs   && r<   Ú	dup_monicr…   þ  s4   € ÷$ Øˆä	�‹€Bà‡x�x�‡|‚|Øˆä  qÓ)Ð)r>   c                ó°   € V'       g   \        W4      # \        W4      '       d   V # \        WV4      pVP                  V4      '       d   V # \	        WW4      # )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   )r4   r@   r6   r„   s   &&& r<   Údmp_ground_monicr‡     sL   € ÷, Ü˜‹Ðä�!×ÒØˆä	�q˜QÓ	€Bà‡x�x�‡|‚|Øˆä  qÓ,Ð,r>   c                óþ   € ^ RI Hp V '       g   VP                  # VP                  pW8X  d   V  F  pVP                  W44      pK  	  V# V  F.  pVP                  W44      pVP	                  V4      '       g   K-   V# 	  V# )a  
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

©ÚQQ)Úsympy.polys.domainsrŠ   r.   Úgcdrƒ   )r4   r6   rŠ   Úcontr9   s   &&   r<   Údup_contentrŽ   ?  st   € õ, 'çØ�v‰vˆà�6‰6€Dà„wÛˆAØ—5‘5˜“>ŠDñ ð €Kó ˆAØ—5‘5˜“>ˆDà�x‰x˜�~Œ~Øà€Kñ ð €Kr>   c           	     ór  € ^ RI Hp V'       g   \        W4      # \        W4      '       d   VP                  # VP                  V^,
          rTW#8X  d(   V  F  pVP                  V\        WeV4      4      pK!  	  V# V  F9  pVP                  V\        WeV4      4      pVP                  V4      '       g   K8   V# 	  V# )a-  
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Œ   Údmp_ground_contentrƒ   )r4   r@   r6   rŠ   r�   rA   r9   s   &&&    r<   r�   r�   i  s¦   € õ, 'çÜ˜1Ó Ð ä�!×ÒØ�v‰vˆà�f‰f�a˜!•eˆ!à„wÛˆAØ—5‘5˜Ô1°!¸Ó:Ó;ŠDñ ð €Kó ˆAØ—5‘5˜Ô1°!¸Ó:Ó;ˆDà�x‰x˜�~Œ~Øà€Kñ ð €Kr>   c                ó”   € V '       g   VP                   V 3# \        W4      pVP                  V4      '       d   W 3# V\        WV4      3# )a@  
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   )r4   r6   r�   s   && r<   Údup_primitiver’   –  sE   € ÷, Ø�v‰v�qˆyÐä�qÓ€Dà‡x�x�‡~‚~Øˆwˆà”^ A¨QÓ/Ð/Ð/r>   c                óÎ   € V'       g   \        W4      # \        W4      '       d   VP                  V 3# \        WV4      pVP	                  V4      '       d   W03# V\        WW4      3# )af  
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   )r4   r@   r6   r�   s   &&& r<   Údmp_ground_primitiver”   ·  s]   € ÷, Ü˜QÓ"Ð"ä�!×ÒØ�v‰v�qˆyÐä˜a AÓ&€Dà‡x�x�‡~‚~Øˆwˆà”^ A¨QÓ2Ð2Ð2r>   c                ó¶   € \        W4      p\        W4      pVP                  W44      pVP                  V4      '       g   \        WV4      p \        WV4      pWPV3# )zõ
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   )r4   r7   r6   ÚfcÚgcrŒ   s   &&&   r<   Údup_extractr˜   Û  sT   € ô 
�QÓ	€BÜ	�QÓ	€Bà
�%‰%�‹-€Cà�8‰8�C�=Š=Ü˜1 1Ó%ˆÜ˜1 1Ó%ˆà�1ˆ9Ðr>   c                óº   € \        WV4      p\        WV4      pVP                  WE4      pVP                  V4      '       g   \        WW#4      p \        WW#4      pW`V3# )zü
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   )r4   r7   r@   r6   r–   r—   rŒ   s   &&&&   r<   Údmp_ground_extractrš   õ  sX   € ô 
˜A !Ó	$€BÜ	˜A !Ó	$€Bà
�%‰%�‹-€Cà�8‰8�C�=Š=Ü˜1 1Ó(ˆÜ˜1 1Ó(ˆà�1ˆ9Ðr>   c                ó’  € VP                   '       g%   VP                  '       g   \        RV,          4      h\        ^4      p\        ^4      pV '       g   W#3# VP                  VP
                  ..VP                  .. ..p\        V ^ ,          ^4      pV R,           F)  p\        WT^V4      p\        V\        V^4      ^ ^V4      pK+  	  \        V4      pVP                  4        F^  w  r…V^,          p	V	'       g   \        W%^V4      pK%  V	^8X  d   \        W5^V4      pK;  V	^8X  d   \        W%^V4      pKQ  \        W5^V4      pK`  	  W#3# )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 %src   )rx   Úis_QQr*   r"   Úoner.   r#   r
   r   r%   Úitemsr   r   )
r4   r6   Úf1Úf2r7   rn   r9   ÚHrQ   r5   s
   &&        r<   Údup_real_imagr¢     s&  € ð& �7�7ˆ7˜1Ÿ7Ÿ7˜7ÜÐWÐZ[Õ[Ó\Ð\ä	�!‹€BÜ	�!‹€BçØˆvˆà�5‰5�!—&‘&ˆ/Ð	˜aŸe™e˜W b˜MÐ*€AÜ�1�Q•4˜Ó€Aàˆr�UˆUˆÜ�A˜!˜QÓˆÜ˜œJ q¨!Ó,¨a°°AÓ6Šñ ô 	˜Ó€Aà—‘–	‰ˆØ��EˆçÜ˜  1Ó%ŠBØ�!ŒVÜ˜  1Ó%ŠBØ�!ŒVÜ˜  1Ó%ŠBä˜  1Ó%ŠBñ ð ˆ6€Mr>   c                óz   € \        V 4      p \        \        V 4      ^,
          RR4       F  pW,          ) W&   K  	  V # )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

rM   éþÿÿÿ)Úlistr1   rl   )r4   r6   r8   s   && r<   Ú
dup_mirrorr¦   C  s:   € ô 	ˆQ‹€Aä”3�q“6˜A•:˜r 2Ö&ˆØ•ˆuˆ‹ñ 'ð €Hr>   c                ó¬   € \        V 4      \        V 4      ^,
          TrCp \        V^,
          RR4       F  pW@V,          ,          WA,          uW&   pK  	  V # )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

rM   ©r¥   rl   r1   )r4   r_   r6   r:   Úbr8   s   &&&   r<   Ú	dup_scalerª   Y  sN   € ô �1‹g”s˜1“v •z 1ˆ!€Aä�1�q•5˜"˜bÖ!ˆØ�a•D•&˜!�#ˆˆ‰Šañ "ð €Hr>   c                óÜ   € \        V 4      \        V 4      ^,
          r0\        V^ R4       F>  p\        ^ V4       F+  pW^,           ;;,          WV,          ,          ,          uu&   K-  	  K@  	  V # )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

rM   r¨   )r4   r_   r6   r:   r8   r;   s   &&&   r<   Ú	dup_shiftr¬   o  sV   € ô �‹7”C˜“F˜Q•J€qä�1�a˜Ž_ˆÜ�q˜!–ˆAØ�!�e�H˜˜A�$�Õ�Hó ñ ð €Hr>   c           	     ó*  € V'       g   \        W^ ,          V4      # \        W4      '       d   V # V^ ,          VR,          rT\        V4      '       d%   V  Uu. uF  p\        WeV^,
          V4      NK  	  p pM\	        V 4      p V'       d~   \        V 4      ^,
          p\        V^ R4       FZ  p\        ^ V4       FG  p	\        W	,          WB^,
          V4      p
\        W	^,           ,          W¢^,
          V4      W	^,           &   KI  	  K\  	  \        W4      # u upi )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
rc   rM   )
r¬   r$   ÚanyÚ	dmp_shiftr¥   rl   r1   r   r   r   )r4   r_   r@   r6   Úa0Úa1r9   r:   r8   r;   Úafjs   &&&&       r<   r¯   r¯   †  sá   € ÷& Ü˜˜a�D !Ó$Ð$ä�!×ÒØˆàˆq�T�1�R•5ˆä
ˆ2‡w‚wÙ01Ó3±¨1Œi˜˜q �s AÖ&±ˆÐ3ˆä�‹Gˆç	Ü�‹F�Q�Jˆä�q˜!˜R–ˆAÜ˜1˜a–[�Ü$ Q¥T¨2°­s°AÓ6�Ü" 1¨¥U¥8¨S°Aµ#°qÓ9��a•%“ó !ñ !ô
 �Q‹?Ðùò 4s   ÁDc                ód  € V '       g   . # \        V 4      ^,
          pV ^ ,          .VP                  ..re\        ^ V4       F%  pVP                  \	        VR,          W#4      4       K'  	  \        V R,          VR,          4       F)  w  r‚\	        WQV4      p\        W(V4      p\        WRV4      pK+  	  V# )zí
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

rc   rM   )rl   r�   r1   rN   r	   Úzipr   r   )	r4   r{   Úqr6   r:   rn   ÚQr8   r9   s	   &&&&     r<   Údup_transformr·   ±  s�   € ÷ Øˆ	äˆA‹��
€AØˆa�Dˆ6�Q—U‘U�G�9€qä�1�aŽ[ˆØ	�‰”˜˜2� Ó%Ö&ñ ô �A�b•E˜1˜R�5Ö!‰ˆÜ�A˜!ÓˆÜ˜1 Ó#ˆÜ�A˜!ÓŠñ "ð
 €Hr>   c           	     óà   € \        V4      ^8:  d!   \        \        V \        W4      V4      .4      # V '       g   . # V ^ ,          .pV R,           F  p\	        W1V4      p\        W4^ V4      pK  	  V# )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

rc   )rl   r   ra   r   r	   r   )r4   r7   r6   rn   r9   s   &&&  r<   Údup_composer¹   Ð  sn   € ô ˆ1ƒv�„{Üœ( 1¤f¨Q£l°AÓ6Ð7Ó8Ð8çØˆ	à	
ˆ1�ˆ€Aàˆr�UˆUˆÜ�A˜!ÓˆÜ˜˜q !Ó$Šñ ð €Hr>   c                óº   € V'       g   \        WV4      # \        W4      '       d   V # V ^ ,          .pV R,           F  p\        WAW#4      p\        WE^ W#4      pK  	  V# )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

rc   )r¹   r$   r
   r   )r4   r7   r@   r6   rn   r9   s   &&&&  r<   Údmp_composer»   í  s`   € ÷ Ü˜1 Ó#Ð#ä�!×ÒØˆà	
ˆ1�ˆ€Aàˆr�UˆUˆÜ�A˜!ÓˆÜ˜˜q !Ó'Šñ ð €Hr>   c                ó  € \        V 4      ^,
          p\        W4      p\        V 4      p WP                  /pW1,          p\	        ^V4       F¶  pVP
                  p\	        ^ V4       Fo  p	W9,           V,
          V 9   g   K  W,
          V9   g   K(  WV	,           V,
          ,          WQV	,
          ,          rºW‡Wi,          ,
          V
,          V,          ,          pKq  	  VP                  W‡V,          V,          4      WQV,
          &   K¸  	  \        WR4      # )ú+Helper function for :func:`_dup_decompose`.)rl   r   r%   r�   r1   r.   Úquor&   )r4   Úsr6   r:   r„   r7   Úrr8   rP   r;   r–   r—   s   &&&         r<   Ú_dup_right_decomposerÁ   
  sÑ   € äˆA‹��
€AÜ	�‹€Bä˜Ó€AØ
�U‰Uˆ€Aà	�€Aä�1�aŽ[ˆØ—‘ˆä�q˜!–ˆAØ•5˜1•9 ”>Ùà•5˜A”:Ùà˜1•u˜q•y•\ 1¨¥U¥8�Ø˜!�#•g˜r•\ "•_Õ$ŠEñ ð —5‘5˜ !¥ B¥Ó'ˆˆa�%‹ñ ô ˜QÓ"Ð"r>   c                óž   € / ^ rCV '       d9   \        WV4      w  rV\        V4      ^ 8”  d   R# \        Wb4      W4&   YT^,           r@K@  \        W24      # )r½   N)r   r   r   r&   )r4   rn   r6   r7   r8   rµ   rÀ   s   &&&    r<   Ú_dup_left_decomposerÃ   &  sH   € àˆq€qç
Ü�q˜QÓ‰ˆä�a‹=˜1ÔÙä˜!“<ˆA‰DØ˜!•eŠqä˜QÓ"Ð"r>   c                ó¼   € \        V 4      ^,
          p\        ^V4       F9  pW#,          ^ 8w  d   K  \        WV4      pVf   K$  \        WV4      pVf   K6  WT3u # 	  R# )z*Helper function for :func:`dup_decompose`.N)rl   r1   rÁ   rÃ   )r4   r6   Údfr¿   rn   r7   s   &&    r<   Ú_dup_decomposerÆ   6  sY   € ä	ˆQ‹�!�€Bä�1�bŽ\ˆØ�6�QŒ;Ùä   qÓ)ˆàŒ=Ü# A¨!Ó,ˆAàŒ}Ø�t’ñ ñ r>   c                ó\   € . p \        W4      pVe   Vw  rV.V,           pK    T .T,           # )a  
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Æ   )r4   r6   ÚFr`   rn   s   &&   r<   Údup_decomposerÉ   I  s=   € ðH 	€Aà
Ü Ó%ˆàÒØ‰DˆAØ��a•ŠAààˆ3��7€Nr>   c                ó´   € VP                   '       g   VP                  '       d   \        WV4      # VP                  '       d   \	        WV4      # \        R4      h)aI  
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 domain)Úis_GaussianRingÚis_GaussianFieldÚ_dmp_alg_inject_gaussianÚis_AlgebraicÚ_dmp_alg_inject_algr*   )r4   r@   r6   s   &&&r<   Údmp_alg_injectrÐ   {  sJ   € ð, 	××Ð˜A×.×.Ð.Ü'¨¨aÓ0Ð0Ø	
��ˆÜ" 1¨Ó+Ð+äÐOÓPÐPr>   c                ó.  € \        W4      / r0V P                  4        FD  w  rEVP                  VP                  rvV'       d   WcRV,           &   V'       g   K9  WsRV,           &   KF  	  \	        W1^,           VP
                  4      pW�^,           VP
                  3# )ú+Helper function for :func:`dmp_alg_inject`.)é    )rd   )r   rž   ÚxÚyr   Údom)	r4   r@   r6   rn   Úf_monomr7   rÔ   rÕ   rÈ   s	   &&&      r<   rÍ   rÍ   ™  sw   € ä�qÓ˜b€qà—g‘g–i‰
ˆØ�s‰s�A—C‘Cˆ1ßØ !ˆd�W�nÑß‰1Ø !ˆd�W�nÓñ  ô 	�a˜Q� §¡Ó&€Aà�!�e�Q—U‘Uˆ?Ðr>   c                ó  € \        W4      / r0V P                  4        F6  w  rEVP                  4       P                  4        F  w  rgWsWd,           &   K  	  K8  	  \        W1^,           VP                  4      pW�^,           VP                  3# )rÒ   )r   rž   Úto_dictr   rÖ   )	r4   r@   r6   rn   r×   r7   Úg_monomr9   rÈ   s	   &&&      r<   rÏ   rÏ   ©  sn   € ä�qÓ˜b€qà—g‘g–i‰
ˆØŸ)™)›+×+Ñ+Ö-‰JˆGØ#$ˆgÕÓ ó .ñ  ô 	�a˜Q� §¡Ó&€Aà�!�e�Q—U‘Uˆ?Ðr>   c           
     óÂ   € ^RI Hp \        WV4      w  rEpVP                  P	                  4       p\        V\        \        ^V^,           4      4      ^ V4      pV! WHWV4      # )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**4 + x**2 + 4*x + 4

)Údmp_resultant)ÚeuclidtoolsrÜ   rÐ   ÚmodÚto_listr(   r¥   r1   )	r4   r@   r6   rÜ   rÈ   rA   ÚK2Úp_aÚP_As	   &&&      r<   Údmp_liftrã   ¶  sR   € õ( +ä˜a AÓ&�H€Aˆ"à
�%‰%�-‰-‹/€CÜ
�cœ4¤ a¨¨Q­£Ó0°!°RÓ
8€Cá˜ Ó'Ð'r>   c                óB  a€ V3R lpSP                   '       g%   SP                  '       g   SP                  '       d   SP                  pEMSP                  '       d    SP
                  P                  '       d   TpMãSP                  '       g   SP                  '       d®   \        SP                  4      ^8X  d”   SP                  P                   '       g/   SP                  P                  '       g   SP                  '       dJ   SP                  ^ ,          P                  '       d'   SP                  ^ ,          P                  '       d   TpM\        RS,          4      hSP                  ^ rTV  F,  pV! Wd,          4      '       d
   V^,          pV'       g   K*  TpK.  	  V# )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                 óR   <€ V '       g   R # \        SP                  V 4      ^ 8  4      # )F)ÚboolÚto_sympy)r_   r6   s   &€r<   Úis_negative_sympyÚ.dup_sign_variations.<locals>.is_negative_sympyâ  s#   ø€ ßáô ˜Ÿ
™
 1›¨Ñ)Ó*Ð*r>   z-sign variation counting not supported over %s)rx   rœ   Úis_RRÚis_negativeÚis_AlgebraicFieldÚextÚis_comparableÚis_PolynomialRingÚis_FractionFieldrl   ÚsymbolsrÖ   Úis_transcendentalr*   r.   )r4   r6   rè   rë   ÚprevrQ   rP   s   &f     r<   Údup_sign_variationsrô   Ô  s  ø€ õ
+ð  	‡w‡w€w�!—'—'�'˜QŸWŸW˜WØ—m‘mŠØ	
×	×	Ð	 §¡×!4×!4Ð!4Ø'‰Ø××Ð !×"4×"4Ð"4¼#¸a¿i¹i».ÈAÔ:MØ�5‰5�;�;ˆ;˜!Ÿ%™%Ÿ+Ÿ+˜+¨×)<×)<Ð)<Ø
�)‰)�A�,×
(×
(Ð
(¨Q¯Y©Y°q­\×-G×-GÐ-Gð (‰äÐIÈAÕMÓNÐNà�f‰f�aˆ!ãˆÙ�u•z×"Ò"Ø��FˆAç‰5ØŠDñ ð €Hr>   Nc           
     óâ  € Vf&   VP                   '       d   VP                  4       pMTpVP                  pV  F#  pVP                  WAP	                  V4      4      pK%  	  VP                  V4      '       d   V'       g   W@3# V\        WV4      3# V  Uu. uF8  qQP                  V4      VP                  WAP	                  V4      4      ,          NK:  	  p pV'       g   V\        WV4      3# W@3# u upi )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)

)	Úhas_assoc_RingÚget_ringr�   ÚlcmÚdenomrƒ   r   Únumerr¾   )r4   ÚK0ÚK1r^   Úcommonr9   s   &&&&  r<   Údup_clear_denomsrþ     sÓ   € ð$ 
‚zØ××ÐØ—‘“‰BàˆBà�V‰V€FãˆØ—‘˜§¡¨£Ó,Šñ ð 
‡y�y�×ÒßØ�9Ðàœ; q¨bÓ1Ð1Ð1ñ ;<Ó<¹!°Q�‰�!‹�R—V‘V˜F§H¡H¨Q£KÓ0×	0Ð	0¹!€AÐ<çØ”{ 1¨"Ó-Ð-Ð-àˆyÐùò 	=s   Â>C,c           
     óà   € VP                   pV'       g,   V  F#  pVP                  WBP                  V4      4      pK%  	  V# V^,
          pV  F  pVP                  V\        WVW#4      4      pK!  	  V# )z.Recursive helper for :func:`dmp_clear_denoms`.)r�   rø   rù   Ú_rec_clear_denoms)r7   rA   rû   rü   rý   r9   rF   s   &&&&   r<   r   r   8  si   € à�V‰V€FçÛˆAØ—V‘V˜F§H¡H¨Q£KÓ0ŠFñ ð €Mð ��EˆãˆAØ—V‘V˜FÔ$5°a¸BÓ$CÓDŠFñ ð €Mr>   c                ó  € V'       g   \        WW4R7      # Vf&   VP                  '       d   VP                  4       pMTp\        WW#4      pVP	                  V4      '       g   \        WW4      p V'       g   WP3# V\        WW#4      3# )a*  
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^   )rþ   rö   r÷   r   rƒ   r   r   )r4   r@   rû   rü   r^   rý   s   &&&&& r<   Údmp_clear_denomsr  H  sy   € ÷$ Ü  rÔ;Ð;à	‚zØ××ÐØ—‘“‰BàˆBä˜q RÓ,€Fà�9‰9�V×ÒÜ˜1 aÓ,ˆçØˆyÐà”{ 1¨Ó0Ð0Ð0r>   c                ó˜  € VP                  \        W4      4      .pVP                  VP                  VP                  .p\	        \        \        V4      4      4      p\        ^V^,           4       FW  p\        W2! ^4      V4      p\        V \        W24      V4      p\        \        WxV4      WB4      p\        V\        V4      V4      pKY  	  V# )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

)Úrevertr    r�   r.   rz   Ú_ceilÚ_log2r1   r   r	   r   r   r   r   r   )	r4   r:   r6   r7   rn   ÚNr8   r_   r©   s	   &&&      r<   Ú
dup_revertr  n  s§   € ð( 
�‰”&˜“,Ó	Ð €AØ	
�‰�—‘˜Ÿ™Ð€AäŒE”%˜“(‹OÓ€Aä�1�a˜!•eŽ_ˆÜ˜1˜a ›d AÓ&ˆÜ�A”w˜q“} aÓ(ˆÜ”G˜A !Ó$ aÓ+ˆÜ�qœ* Q›-¨Ó+Šñ	 ð €Hr>   c                ó@   € V'       g   \        WV4      # \        W4      h)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)   )r4   r7   r@   r6   s   &&&&r<   Ú
dmp_revertr
  �  s   € ÷ Ü˜! Ó"Ð"ä)¨!Ó/Ð/r>   )NF)cÚ__doc__Úsympy.polys.densearithr   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'   r(   Úsympy.polys.polyerrorsr)   r*   Úmathr+   r  r,   r  r=   rB   rD   rK   rR   rT   rV   r[   ra   re   rg   ri   rk   rq   rs   rv   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
  © r>   r<   Ú<module>r     s\  ðÙ N÷÷ ÷ ÷ ÷ ñ ÷÷ ÷ ÷ ÷ ó ÷÷
 .òò@ òFLò/ò,(òV,ò^Gò*ò0ò4ò:Gò*ò0
1ò(ò@Lò/ò4òD@ò(Eò0*ò:!-òH'òT*òZ0òB!3òHò4ò41òhò,ò,ò.(òVò>ò:ò:#ò8#ò ò&/òdQò<ò 
ò(ò<4ôn*òZô #1òLôD0r>   