ó
    Š*£h2t  ã                   ó  • S r SSKJrJrJrJrJrJrJrJ	r	J
r
JrJrJrJrJrJrJrJrJrJr  SSKJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)  SSK*J+r+J,r,  SSK-J.r/J0r1  S r2S r3S r4S	 r5S
 r6S r7S r8S r9S r:S r;S r<S r=S r>S r?S r@S rAS rBS rCS rDS rES rFS rGS rHS rIS rJS rKS  rLS! rMS" rNS# rOS$ rPS% rQS& rRS' rSS( rTS) rUS* rVS+ rWS, rXS- rYS. rZS/ r[S0 r\S1 r]S8S3 jr^S4 r_S8S5 jr`S6 raS7 rbg2)9zHAdvanced 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           
      ó  • US::  d  U (       d  U $ UR                   /U-  n[        [        U 5      5       HN  u  pEUS-   n[        SU5       H  nXdU-   S-   -  nM     UR	                  SUR                  XR" U5      5      5        MP     U$ )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

r   é   )ÚzeroÚ	enumerateÚreversedÚrangeÚinsertÚexquo)ÚfÚmÚKÚgÚiÚcÚnÚjs           ÚS/home/mande/repo/quber/.venv/lib/python3.13/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           
      óD  • U(       d  [        XU5      $ US::  d  [        X5      (       a  U $ [        XS-
  U5      US-
  pT[        [	        U 5      5       HI  u  pgUS-   n[        SU5       H  n	X†U	-   S-   -  nM     UR                  S[        Xs" U5      XS5      5        MK     U$ )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%   r(   r1   r2   r3   r4   r   )
r6   r7   Úur8   r9   Úvr:   r;   r<   r=   s
             r>   Údmp_integraterD   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                 ó�   • X4:X  a  [        XX%5      $ US-
  US-   p6[        U  Vs/ s H  n[        XqXcXE5      PM     snU5      $ s  snf )z.Recursive helper for :func:`dmp_integrate_in`.r/   )rD   r   Ú_rec_integrate_in©r9   r7   rC   r:   r=   r8   Úwr;   s           r>   rF   rF   j   sL   € àƒvÜ˜Q 1Ó(Ð(àˆq‰5�!�a‘%€qäÁAÓGÂA¸qÔ(¨¨q°QÖ:ÁAÑGÈÓKÐKùÒGó   ¤Ac                 óR   • US:  d  X#:”  a  [        SX24-  5      e[        XUSX$5      $ )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)Ú
IndexErrorrF   ©r6   r7   r=   rB   r8   s        r>   Údmp_integrate_inrM   t   s3   € ð  	ˆ1ƒu�“ÜÐCÀqÀfÑLÓMÐMä˜Q 1 a¨Ó.Ð.r@   c                 óL  • US::  a  U $ [        U 5      nX1:  a  / $ / nUS:X  a-  U SU*   H"  nUR                  U" U5      U-  5        US-  nM$     OKU SU*   HA  nUn[        US-
  X1-
  S5       H  nXg-  nM	     UR                  U" U5      U-  5        US-  nMC     [        U5      $ )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

r   r/   Néÿÿÿÿ)r   Úappendr3   r   )r6   r7   r8   r<   ÚderivÚcoeffÚkr:   s           r>   Údup_diffrT   Š   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           	      ó¨  • U(       d  [        XU5      $ US::  a  U $ [        X5      nXA:  a  [        U5      $ / US-
  peUS:X  a4  U SU*   H)  nUR                  [	        Xs" U5      Xc5      5        US-  nM+     ORU SU*   HH  nUn[        US-
  XA-
  S5       H  n	X‰-  nM	     UR                  [	        Xs" U5      Xc5      5        US-  nMJ     [        XR5      $ )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

r   r/   NrO   )rT   r   r#   rP   r   r3   r   )
r6   r7   rB   r8   r<   rQ   rC   rR   rS   r:   s
             r>   Údmp_diffrV   µ   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                 ó�   • X4:X  a  [        XX%5      $ US-
  US-   p6[        U  Vs/ s H  n[        XqXcXE5      PM     snU5      $ s  snf )z)Recursive helper for :func:`dmp_diff_in`.r/   )rV   r   Ú_rec_diff_inrG   s           r>   rX   rX   ä   óK   € àƒvÜ˜˜aÓ#Ð#àˆq‰5�!�a‘%€qä¹qÓBºq¸!”| A¨!°Ö5¹qÑBÀAÓFÐFùÒBrI   c                 óZ   • US:  d  X#:”  a  [        SU< SU< 35      e[        XUSX$5      $ )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

r   ú
0 <= j <= ú expected, got )rK   rX   rL   s        r>   Údmp_diff_inr]   î   ó0   € ð$ 	ˆ1ƒu�“Ý»AºqÐAÓBÐBä˜˜a  AÓ)Ð)r@   c                 ó‚   • U(       d  UR                  [        X5      5      $ UR                  nU  H  nX1-  nX4-  nM     U$ )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!   r0   )r6   Úar8   Úresultr;   s        r>   Údup_evalrc     sB   € ö Ø�y‰yœ ›Ó&Ð&à�V‰V€FãˆØ‰ˆØ‰Šñ ð €Mr@   c                 ó¶   • U(       d  [        XU5      $ U(       d  [        X5      $ [        X5      US-
  pTU SS  H  n[        XAXS5      n[	        XFXS5      nM     U$ )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)rc   r"   r   r   r   )r6   ra   rB   r8   rb   rC   rR   s          r>   Údmp_evalre      s_   € ö Ü˜˜aÓ Ð æÜ�a‹|Ðä�q“˜a !™eˆAà�1�2“ˆÜ ¨1Ó0ˆÜ˜¨Ó-Šñ ð €Mr@   c                 ó�   • X4:X  a  [        XX%5      $ US-
  US-   p2[        U  Vs/ s H  n[        XaX#XE5      PM     snU5      $ s  snf )z)Recursive helper for :func:`dmp_eval_in`.r/   )re   r   Ú_rec_eval_in)r9   ra   rC   r:   r=   r8   r;   s          r>   rg   rg   =  rY   rI   c                 óZ   • US:  d  X#:”  a  [        SU< SU< 35      e[        XUSX$5      $ )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

r   r[   r\   )rK   rg   )r6   ra   r=   rB   r8   s        r>   Údmp_eval_inri   G  r^   r@   c           
      óÌ   • X:X  a  [        XS   U5      $ U  Vs/ s H  n[        XQS-   X#U5      PM     nnX[        U5      -
  S-   :  a  U$ [        XbU* U-   S-
     U5      $ s  snf )z+Recursive helper for :func:`dmp_eval_tail`.rO   r/   )rc   Ú_rec_eval_tailÚlen)r9   r:   ÚArB   r8   r;   Ú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                 óÔ   • U(       d  U $ [        X5      (       a  [        U[        U5      -
  5      $ [        U SXU5      nU[        U5      S-
  :X  a  U$ [	        XB[        U5      -
  5      $ )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/   )r%   r#   rl   rk   r   )r6   rm   rB   r8   Úes        r>   Údmp_eval_tailrq   l  sa   € ö$ Øˆä�!×ÑÜ˜œC ›F™
Ó#Ð#ä�q˜!˜Q 1Ó%€AàŒC�‹F�Q‰JƒØˆä˜¤ A£™JÓ'Ð'r@   c                 ó¨   • XE:X  a  [        [        XX65      X#U5      $ US-
  US-   pC[        U  Vs/ s H  n[        XqX#XEU5      PM     snU5      $ s  snf )z+Recursive helper for :func:`dmp_diff_eval`.r/   )re   rV   r   Ú_rec_diff_eval)r9   r7   ra   rC   r:   r=   r8   r;   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           	      ó’   • X4:”  a  [        SU< SU< SU< 35      eU(       d  [        [        XXE5      X$U5      $ [        XX$SX55      $ )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 < r\   r   )rK   re   rV   rs   )r6   r7   ra   r=   rB   r8   s         r>   Údmp_diff_eval_inrv   –  sE   € ð$ 	ƒuÝ»QÃÂ1ÐEÓFÐFÞÜœ  qÓ,¨a°AÓ6Ð6ä˜!  a¨Ó.Ð.r@   c                 ór  • UR                   (       a>  / nU  H5  nXA-  nXAS-  :”  a  UR                  XA-
  5        M$  UR                  U5        M7     OTUR                  (       a/  [        U5      nU  Vs/ s H  oB" [        U5      U-  5      PM     nnOU  Vs/ s H  oDU-  PM	     nn[	        U5      $ s  snf s  snf )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_ZZrP   Úis_FiniteFieldÚintr   )r6   Úpr8   r9   r;   Úpis         r>   Ú	dup_truncr~   °  s    € ð 	‡w‡wØˆãˆAØ‘ˆAà˜‘6‹zØ—‘˜™–à—‘˜–ò ð 
×	×	ä�‹VˆÙ&'Ó)¢a ˆa”�A“˜‘Žn¡aˆÐ)ˆáÓ šQ˜�!Œe™QˆÐ ä�Q‹<Ðùò	 *ùâ s   Á0B/ÂB4c                 ób   • [        U  Vs/ s H  n[        XAUS-
  U5      PM     snU5      $ s  snf )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   r   )r6   r|   rB   r8   r;   s        r>   Ú	dmp_truncr€   Ò  s0   € ô" ¹Ó;º°1”w˜q Q¨¡U¨AÖ.¹Ñ;¸QÓ?Ð?ùÒ;s   Š,c                 óŠ   • U(       d  [        XU5      $ US-
  n[        U  Vs/ s H  n[        XQXC5      PM     snU5      $ s  snf )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~   r   Údmp_ground_trunc)r6   r|   rB   r8   rC   r;   s         r>   r‚   r‚   æ  sD   € ö  Ü˜˜qÓ!Ð!à	ˆA‰€Aä¹QÓ@ºQ¸Ô'¨¨aÖ3¹QÑ@À!ÓDÐDùÒ@s   ¢A c                 ór   • U (       d  U $ [        X5      nUR                  U5      (       a  U $ [        XU5      $ )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   )r6   r8   Úlcs      r>   Ú	dup_monicr†   þ  s4   € ö$ Øˆä	�‹€Bà‡x�x�‡|�|Øˆä  qÓ)Ð)r@   c                 óª   • U(       d  [        X5      $ [        X5      (       a  U $ [        XU5      nUR                  U5      (       a  U $ [	        XX5      $ )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   )r6   rB   r8   r…   s       r>   Údmp_ground_monicrˆ     sL   € ö, Ü˜‹Ðä�!×ÑØˆä	�q˜QÓ	€Bà‡x�x�‡|�|Øˆä  qÓ,Ð,r@   c                 óø   • SSK Jn  U (       d  UR                  $ UR                  nX:X  a  U  H  nUR                  X45      nM     U$ U  H-  nUR                  X45      nUR	                  U5      (       d  M,    U$    U$ )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

r   ©ÚQQ)Úsympy.polys.domainsr‹   r0   Úgcdr„   )r6   r8   r‹   Úcontr;   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           	      ób  • SSK Jn  U(       d  [        X5      $ [        X5      (       a  UR                  $ UR                  US-
  pTX#:X  a'  U  H  nUR                  U[        XeU5      5      nM!     U$ U  H8  nUR                  U[        XeU5      5      nUR                  U5      (       d  M7    U$    U$ )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%   r0   r�   Údmp_ground_contentr„   )r6   rB   r8   r‹   rŽ   rC   r;   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                 ó�   • U (       d  UR                   U 4$ [        X5      nUR                  U5      (       a  X 4$ U[        XU5      4$ )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)

)r0   r�   r„   r   )r6   r8   rŽ   s      r>   Údup_primitiver“   –  sE   € ö, Ø�v‰v�qˆyÐä�qÓ€Dà‡x�x�‡~�~Øˆwˆà”^ A¨QÓ/Ð/Ð/r@   c                 óÈ   • U(       d  [        X5      $ [        X5      (       a  UR                  U 4$ [        XU5      nUR	                  U5      (       a  X04$ U[        XX5      4$ )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%   r0   r‘   r„   r   )r6   rB   r8   rŽ   s       r>   Údmp_ground_primitiver•   ·  s]   € ö, Ü˜QÓ"Ð"ä�!×ÑØ�v‰v�qˆyÐä˜a AÓ&€Dà‡x�x�‡~�~Øˆwˆà”^ A¨QÓ2Ð2Ð2r@   c                 ó´   • [        X5      n[        X5      nUR                  X45      nUR                  U5      (       d  [        XU5      n [        XU5      nXPU4$ )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   )r6   r9   r8   ÚfcÚgcr�   s         r>   Údup_extractr™   Û  sT   € ô 
�QÓ	€BÜ	�QÓ	€Bà
�%‰%�‹-€Cà�8‰8�C�=‰=Ü˜1 1Ó%ˆÜ˜1 1Ó%ˆà�1ˆ9Ðr@   c                 ó¸   • [        XU5      n[        XU5      nUR                  XE5      nUR                  U5      (       d  [        XX#5      n [        XX#5      nX`U4$ )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   )r6   r9   rB   r8   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                 óf  • UR                   (       d  UR                  (       d  [        SU-  5      e[        S5      n[        S5      nU (       d  X#4$ UR                  UR
                  //UR                  // //n[        U S   S5      nU SS  H)  n[        XTSU5      n[        U[        US5      SSU5      nM+     [        U5      nUR                  5        HW  u  p…US-  n	U	(       d  [        X%SU5      nM   U	S:X  a  [        X5SU5      nM5  U	S:X  a  [        X%SU5      nMJ  [        X5SU5      nMY     X#4$ )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   rx   Né   )ry   Úis_QQr+   r#   Úoner0   r$   r   r   r&   Úitemsr   r	   )
r6   r8   Úf1Úf2r9   rn   r;   ÚHrS   r7   s
             r>   Údup_real_imagr¤     s"  € ð& �7�7˜1Ÿ7Ÿ7ÜÐWÐZ[Ñ[Ó\Ð\ä	�!‹€BÜ	�!‹€BæØˆvˆà�5‰5�!—&‘&ˆ/Ð	˜aŸe™e˜W b˜MÐ*€AÜ�1�Q‘4˜Ó€Aàˆqˆr‹UˆÜ�A˜!˜QÓˆÜ˜œJ q¨!Ó,¨a°°AÓ6Šñ ô 	˜Ó€Aà—‘–	‰ˆØ�‰EˆæÜ˜  1Ó%ŠBØ�!‹VÜ˜  1Ó%ŠBØ�!‹VÜ˜  1Ó%ŠBä˜  1Ó%ŠBñ ð ˆ6€Mr@   c                 ój   • [        U 5      n [        [        U 5      S-
  SS5       H
  nX   * X'   M     U $ )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

rx   rO   éþÿÿÿ)Úlistr3   rl   )r6   r8   r:   s      r>   Ú
dup_mirrorr¨   C  s:   € ô 	ˆQ‹€Aä”3�q“6˜A‘:˜r 2Ö&ˆØ‘ˆuˆ‹ñ 'ð €Hr@   c                 ó„   • [        U 5      [        U 5      S-
  UpCn [        US-
  SS5       H  nX@U   -  XA-  sX'   nM     U $ )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/   rO   ©r§   rl   r3   )r6   ra   r8   r<   Úbr:   s         r>   Ú	dup_scaler¬   Y  sN   € ô �1‹g”s˜1“v ‘z 1ˆ!€Aä�1�q‘5˜"˜bÖ!ˆØ�a‘D‘&˜!™#ˆˆ‰Šañ "ð €Hr@   c                 ó¬   • [        U 5      [        U 5      S-
  p0[        USS5       H*  n[        SU5       H  nXS-   ==   XU   -  -  ss'   M     M,     U $ )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   rO   rª   )r6   ra   r8   r<   r:   r=   s         r>   Ú	dup_shiftr®   o  sV   € ô �‹7”C˜“F˜Q‘J€qä�1�a˜Ž_ˆÜ�q˜!–ˆAØ�!‰e‹H˜˜A™$™Ñ�Hó ñ ð €Hr@   c           	      óÌ  • U(       d  [        XS   U5      $ [        X5      (       a  U $ US   USS pT[        U5      (       a!  U  Vs/ s H  n[        XeUS-
  U5      PM     n nO[	        U 5      n U(       aa  [        U 5      S-
  n[        USS5       HB  n[        SU5       H/  n	[        X	   XBS-
  U5      n
[        X	S-      X¢S-
  U5      X	S-   '   M1     MD     [        X5      $ s  snf )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/   NrO   )
r®   r%   ÚanyÚ	dmp_shiftr§   rl   r3   r   r   r   )r6   ra   rB   r8   Úa0Úa1r;   r<   r:   r=   Úafjs              r>   r±   r±   †  sã   € ö& Ü˜˜a™D !Ó$Ð$ä�!×ÑØˆàˆq‰T�1�Q�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   ÁC!c                 ó:  • U (       d  / $ [        U 5      S-
  nU S   /UR                  //pe[        SU5       H!  nUR                  [	        US   X#5      5        M#     [        U SS USS 5       H)  u  p‚[	        XQU5      n[        X(U5      n[        XRU5      nM+     U$ )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

r/   r   rO   N)rl   rŸ   r3   rP   r
   Úzipr   r   )	r6   r|   Úqr8   r<   rn   ÚQr:   r;   s	            r>   Údup_transformr¹   ±  s¡   € ö Øˆ	äˆA‹�‰
€AØˆa‰Dˆ6�Q—U‘U�G�9€qä�1�aŽ[ˆØ	�‰”˜˜2™ Ó%Ö&ñ ô �A�a�b�E˜1˜Q˜R˜5Ö!‰ˆÜ�A˜!ÓˆÜ˜1 Ó#ˆÜ�A˜!ÓŠñ "ð
 €Hr@   c           	      óÌ   • [        U5      S::  a   [        [        U [        X5      U5      /5      $ U (       d  / $ U S   /nU SS  H  n[	        X1U5      n[        X4SU5      nM     U$ )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)rl   r   rc   r   r
   r   )r6   r9   r8   rn   r;   s        r>   Údup_composer»   Ð  sn   € ô ˆ1ƒv�ƒ{Üœ( 1¤f¨Q£l°AÓ6Ð7Ó8Ð8æØˆ	à	
ˆ1‰ˆ€Aàˆqˆr‹UˆÜ�A˜!ÓˆÜ˜˜q !Ó$Šñ ð €Hr@   c                 ó¦   • U(       d  [        XU5      $ [        X5      (       a  U $ U S   /nU SS  H  n[        XAX#5      n[        XESX#5      nM     U$ )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   )r6   r9   rB   r8   rn   r;   s         r>   Údmp_composer½   í  s`   € ö Ü˜1 Ó#Ð#ä�!×ÑØˆà	
ˆ1‰ˆ€Aàˆqˆr‹UˆÜ�A˜!ÓˆÜ˜˜q !Ó'Šñ ð €Hr@   c                 óŠ  • [        U 5      S-
  n[        X5      n[        U 5      n XR                  0nX1-  n[	        SU5       Ht  nUR
                  n[	        SU5       H9  n	X9-   U-
  U ;  a  M  X-
  U;  a  M  XU	-   U-
     XQU	-
     pºX‡Xi-  -
  U
-  U-  -  nM;     UR                  X‡U-  U-  5      XQU-
  '   Mv     [        XR5      $ )ú+Helper function for :func:`_dup_decompose`.r/   r   )rl   r   r&   rŸ   r3   r0   Úquor'   )r6   Úsr8   r<   r…   r9   Úrr:   rR   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                 óž   • 0 SpCU (       a9  [        XU5      u  pV[        U5      S:”  a  g[        Xb5      X4'   XTS-   p@U (       a  M9  [        X25      $ )r¿   r   Nr/   )r   r   r   r'   )r6   rn   r8   r9   r:   r·   rÂ   s          r>   Ú_dup_left_decomposerÅ   &  sQ   € àˆq€qæ
Ü�q˜QÓ‰ˆä�a‹=˜1ÓØä˜!“<ˆA‰DØ˜!‘eˆq÷ ˆ!ô ˜QÓ"Ð"r@   c                 ó¤   • [        U 5      S-
  n[        SU5       H2  nX#-  S:w  a  M  [        XU5      nUc  M  [        XU5      nUc  M/  XT4s  $    g)z*Helper function for :func:`dup_decompose`.r/   rx   r   N)rl   r3   rÃ   rÅ   )r6   r8   ÚdfrÁ   rn   r9   s         r>   Ú_dup_decomposerÈ   6  sY   € ä	ˆQ‹�!‰€Bä�1�bŽ\ˆØ‰6�Q‹;Ùä   qÓ)ˆà‹=Ü# A¨!Ó,ˆAà‹}Ø�t’ñ ð r@   c                 óL   • / n [        X5      nUb  Uu  pU/U-   nOOM  U /U-   $ )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È   )r6   r8   ÚFrb   rn   s        r>   Údup_decomposerË   I  sD   € ðH 	€Aà
Ü Ó%ˆàÑØ‰DˆAØ��a‘‰Aàñ ð ˆ3�‰7€Nr@   c                 ó®   • UR                   (       d  UR                  (       a  [        XU5      $ UR                  (       a  [	        XU5      $ [        S5      e)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+   )r6   rB   r8   s      r>   Údmp_alg_injectrÒ   {  sB   € ð, 	××˜A×.×.Ü'¨¨aÓ0Ð0Ø	
��Ü" 1¨Ó+Ð+äÐOÓPÐPr@   c                 ó
  • [        X5      0 p0U R                  5        H:  u  pEUR                  UR                  pvU(       a  XcSU-   '   U(       d  M3  XsSU-   '   M<     [	        X1S-   UR
                  5      nX�S-   UR
                  4$ )ú+Helper function for :func:`dmp_alg_inject`.)r   )r/   r/   )r   r    ÚxÚyr   Údom)	r6   rB   r8   rn   Úf_monomr9   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                 óú   • [        X5      0 p0U R                  5        H2  u  pEUR                  5       R                  5        H  u  pgXsXd-   '   M     M4     [        X1S-   UR                  5      nX�S-   UR                  4$ )rÔ   r/   )r   r    Úto_dictr   r×   )	r6   rB   r8   rn   rØ   r9   Úg_monomr;   rÊ   s	            r>   rÑ   rÑ   ©  sn   € ä�qÓ˜b€qà—g‘g–i‰
ˆØŸ)™)›+×+Ñ+Ö-‰JˆGØ#$ˆgÑÓ ó .ñ  ô 	�a˜Q™ §¡Ó&€Aà�!‰e�Q—U‘Uˆ?Ðr@   c           
      óº   • SSK Jn  [        XU5      u  pEnUR                  R	                  5       n[        U[        [        SUS-   5      5      SU5      nU" XHXV5      $ )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

r/   )Údmp_resultantr   )ÚeuclidtoolsrÝ   rÒ   ÚmodÚto_listr)   r§   r3   )	r6   rB   r8   rÝ   rÊ   rC   ÚK2Úp_aÚP_As	            r>   Údmp_lifträ   ¶  sR   € õ( +ä˜a AÓ&�H€Aˆ"à
�%‰%�-‰-‹/€CÜ
�cœ4¤ a¨¨Q©£Ó0°!°RÓ
8€Cá˜ Ó'Ð'r@   c                 óú  ^• U4S jnTR                   (       d"  TR                  (       d  TR                  (       a  TR                  nOþTR                  (       a  TR
                  R                  (       a  UnOÏTR                  (       d  TR                  (       aŸ  [        TR                  5      S:X  a†  TR                  R                   (       d,  TR                  R                  (       d  TR                  (       a?  TR                  S   R                  (       a!  TR                  S   R                  (       a  UnO[        ST-  5      eTR                  SpTU  H"  nU" Xd-  5      (       a  US-  nU(       d  M   UnM$     U$ )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                 óN   >• U (       d  g[        TR                  U 5      S:  5      $ )NFr   )ÚboolÚto_sympy)ra   r8   s    €r>   Úis_negative_sympyÚ.dup_sign_variations.<locals>.is_negative_sympyâ  s#   ø€ Þàô ˜Ÿ
™
 1›¨Ñ)Ó*Ð*r@   r/   r   z-sign variation counting not supported over %s)ry   rž   Úis_RRÚis_negativeÚis_AlgebraicFieldÚextÚis_comparableÚis_PolynomialRingÚis_FractionFieldrl   Úsymbolsr×   Úis_transcendentalr+   r0   )r6   r8   ré   rì   ÚprevrS   rR   s    `     r>   Údup_sign_variationsrõ   Ô  sò   ø€ õ
+ð  	‡w‡w�!—'—'˜QŸWŸWØ—m‘m‰Ø	
×	×	 §¡×!4×!4Ø'‰Ø×× !×"4×"4¼#¸a¿i¹i».ÈAÓ:MØ�5‰5�;�;˜!Ÿ%™%Ÿ+Ÿ+¨×)<×)<Ø
�)‰)�A‰,×
(×
(¨Q¯Y©Y°q©\×-G×-Gð (‰äÐIÈAÑMÓNÐNà�f‰f�aˆ!ãˆÙ�u‘z×"Ñ"Ø�‰FˆAçˆ5ØŠDñ ð €Hr@   Nc           
      óÒ  • Uc$  UR                   (       a  UR                  5       nOUnUR                  nU  H#  nUR                  XAR	                  U5      5      nM%     UR                  U5      (       a  U(       d  X@4$ U[        XU5      4$ U  Vs/ s H4  oQR                  U5      UR                  XAR	                  U5      5      -  PM6     n nU(       d  U[        XU5      4$ X@4$ s  snf )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À   )r6   ÚK0ÚK1r`   Úcommonr;   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¹!€AÐ<æØ”{ 1¨"Ó-Ð-Ð-àˆyÐùò 	=s   Â;C$c           
      óÖ   • UR                   nU(       d+  U  H#  nUR                  XBR                  U5      5      nM%     U$ US-
  nU  H  nUR                  U[        XVX#5      5      nM!     U$ )z.Recursive helper for :func:`dmp_clear_denoms`.r/   )rŸ   rù   rú   Ú_rec_clear_denoms)r9   rC   rü   rý   rþ   r;   rH   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                 óþ   • U(       d
  [        XX4S9$ Uc$  UR                  (       a  UR                  5       nOUn[        XX#5      nUR	                  U5      (       d  [        XX5      n U(       d  XP4$ U[        XX#5      4$ )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   )r6   rB   rü   rý   r`   rþ   s         r>   Údmp_clear_denomsr  H  sv   € ö$ Ü  rÑ;Ð;à	�zØ××Ø—‘“‰BàˆBä˜q RÓ,€Fà�9‰9�V×ÑÜ˜1 aÓ,ˆæØˆyÐà”{ 1¨Ó0Ð0Ð0r@   c                 ó�  • UR                  [        X5      5      /nUR                  UR                  UR                  /n[	        [        [        U5      5      5      n[        SUS-   5       HW  n[        X2" S5      U5      n[        U [        X25      U5      n[        [        XxU5      XB5      n[        U[        U5      U5      nMY     U$ )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/   rx   )Úrevertr!   rŸ   r0   r{   Ú_ceilÚ_log2r3   r   r
   r   r   r   r   r   )	r6   r<   r8   r9   rn   ÚNr:   ra   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                 ó>   • U(       d  [        XU5      $ [        X5      e)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*   )r6   r9   rB   r8   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?   rD   rF   rM   rT   rV   rX   r]   rc   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@   