Ë
    7^(h2t  ã                   óþ  — d Z ddlmZmZmZmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZ ddlmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) ddl*m+Z+m,Z, ddl-m.Z/m0Z1 d„ Z2d„ Z3d„ 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[d0„ Z\d1„ Z]d8d3„Z^d4„ Z_d8d5„Z`d6„ Zad7„ Zby2)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           
      ó  — |dk  s| s| S |j                   g|z  }t        t        | «      «      D ]N  \  }}|dz   }t        d|«      D ]  }|||z   dz   z  }Œ |j	                  d|j                  | ||«      «      «       ŒP |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           úT/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/polys/densetools.pyÚdup_integrater?   '   s’   € ð  	ˆA‚v‘QØˆà	
�‰ˆ�‰
€Aäœ( 1›+Ó&ò &‰ˆˆ1Ø�‰Eˆä�q˜!“ò 	ˆAØ��Q‘˜‘‰N‰Að	ð 	
�‰��A—G‘G˜A™q ›tÓ$Õ%ð&ð €Hó    c           
      ó6  — |st        | ||«      S |dk  st        | |«      r| S t        ||dz
  |«      |dz
  }}t        t	        | «      «      D ]J  \  }}|dz   }t        d|«      D ]  }	|||	z   dz   z  }Œ |j                  dt        | ||«      ||«      «       ŒL |S )a&  
    Computes the indefinite integral of ``f`` in ``x_0`` in ``K[X]``.

    Examples
    ========

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

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

    r   r/   )r?   r%   r(   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Ô!Øˆä�Q˜˜A™˜qÓ! 1 q¡5€q€Aäœ( 1›+Ó&ò 3‰ˆˆ1Ø�‰Eˆä�q˜!“ò 	ˆAØ��Q‘˜‘‰N‰Að	ð 	
�‰�”N 1¡a¨£d¨A¨qÓ1Õ2ð3ð €Hr@   c                 ó–   — ||k(  rt        | |||«      S |dz
  |dz   }}t        | D �cg c]  }t        ||||||«      ‘Œ c}|«      S c c}w )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   sV   € àˆA‚vÜ˜Q  1 aÓ(Ð(àˆq‰5�!�a‘%€q€AäÀAÖG¸qÔ(¨¨A¨q°!°Q¸Õ:ÒGÈÓKÐKùÒGó   §Ac                 óV   — |dk  s||kD  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)Ú
IndexErrorrF   ©r6   r7   r=   rB   r8   s        r>   Údmp_integrate_inrM   t   s;   € ð  	ˆ1‚u��A’ÜÐCÀqÈ!ÀfÑLÓMÐMä˜Q  1 a¨¨AÓ.Ð.r@   c                 óT  — |dk  r| S t        | «      }||k  rg S g }|dk(  r5| d|  D ]!  }|j                   ||«      |z  «       |dz  }Œ# t        |«      S | d|  D ]@  }|}t        |dz
  ||z
  d«      D ]  }||z  }Œ	 |j                   ||«      |z  «       |dz  }ŒB t        |«      S )a#  
    ``m``-th order derivative of a polynomial in ``K[x]``.

    Examples
    ========

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

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

    r   r/   Néÿÿÿÿ)r   Úappendr3   r   )r6   r7   r8   r<   ÚderivÚcoeffÚkr:   s           r>   Údup_diffrT   Š   så   € ð  	ˆA‚vØˆä�1‹€Aàˆ1‚uØˆ	à€EàˆA‚vØ�s˜˜�Vò 	ˆEØ�L‰L™˜1›˜e™Ô$Ø�‰F‰Að	ô �UÓÐð �s˜˜�Vò 	ˆEØˆAä˜1˜q™5 ! a¡%¨Ó,ò �Ø�Q‘‘ðð �L‰L™˜1›˜e™Ô$Ø�‰F‰Að	ô �UÓÐr@   c           	      ó¢  — |st        | ||«      S |dk  r| S t        | |«      }||k  rt        |«      S g |dz
  }}|dk(  r4| d|  D ]*  }|j                  t	        | ||«      ||«      «       |dz  }Œ, nR| d|  D ]I  }|}t        |dz
  ||z
  d«      D ]  }	||	z  }Œ	 |j                  t	        | ||«      ||«      «       |dz  }ŒK t        ||«      S )a3  
    ``m``-th order derivative in ``x_0`` of a polynomial in ``K[X]``.

    Examples
    ========

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

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

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

    r   r/   NrO   )rT   r   r#   rP   r   r3   r   )
r6   r7   rB   r8   r<   rQ   rC   rR   rS   r:   s
             r>   Údmp_diffrV   µ   s
  € ñ$ Ü˜˜1˜aÓ Ð ØˆA‚vØˆä�1�aÓ€Aàˆ1‚uÜ˜‹{Ðà�1�q‘5ˆ1€EàˆA‚vØ�s˜˜�Vò 	ˆEØ�L‰Lœ¨©q°«t°Q¸Ó:Ô;Ø�‰F‰Añ	ð �s˜˜�Vò 	ˆEØˆAä˜1˜q™5 ! a¡%¨Ó,ò �Ø�Q‘‘ðð �L‰Lœ¨©q°«t°Q¸Ó:Ô;Ø�‰F‰Að	ô �U˜AÓÐr@   c                 ó–   — ||k(  rt        | |||«      S |dz
  |dz   }}t        | D �cg c]  }t        ||||||«      ‘Œ c}|«      S c c}w )z)Recursive helper for :func:`dmp_diff_in`.r/   )rV   r   Ú_rec_diff_inrG   s           r>   rX   rX   ä   óU   € àˆA‚vÜ˜˜1˜a Ó#Ð#àˆq‰5�!�a‘%€q€Aä¸qÖB¸!”| A q¨!¨Q°°1Õ5ÒBÀAÓFÐFùÒBrI   c                 óX   — |dk  s||kD  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 )rK   rX   rL   s        r>   Údmp_diff_inr]   î   ó6   € ð$ 	ˆ1‚u��A’ÝºA¹qÐAÓBÐBä˜˜1˜a  A qÓ)Ð)r@   c                 óz   — |s|j                  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!   r0   )r6   Úar8   Úresultr;   s        r>   Údup_evalrc     sM   € ñ Ø�y‰yœ  1›Ó&Ð&à�V‰V€Fàò ˆØ�!‰ˆØ�!‰‰ðð €Mr@   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

    r/   N)rc   r"   r   r   r   )r6   ra   rB   r8   rb   rC   rR   s          r>   Údmp_evalre      st   € ñ Ü˜˜1˜aÓ Ð áÜ�a˜‹|Ðä�q˜!“˜a !™eˆA€Fà�1�2�ò .ˆÜ ¨¨1¨aÓ0ˆÜ˜ ¨¨1Ó-‰ð.ð €Mr@   c                 ó–   — ||k(  rt        | |||«      S |dz
  |dz   }}t        | D �cg c]  }t        ||||||«      ‘Œ c}|«      S c c}w )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                 óX   — |dk  s||kD  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   r[   r\   )rK   rg   )r6   ra   r=   rB   r8   s        r>   Údmp_eval_inri   G  r^   r@   c           
      óÎ   — ||k(  rt        | |d   |«      S | D �cg c]  }t        ||dz   |||«      ‘Œ }}||t        |«      z
  dz   k  r|S t        ||| |z   dz
     |«      S c c}w )z+Recursive helper for :func:`dmp_eval_tail`.rO   r/   )rc   Ú_rec_eval_tailÚlen)r9   r:   ÚArB   r8   r;   Úhs          r>   rk   rk   _  s{   € àˆA‚vÜ˜˜1˜R™5 !Ó$Ð$à9:Ö<°AŒn˜Q  A¡ q¨!¨QÕ/Ð<ˆÐ<àˆq”3�q“6‰z˜A‰~ÒØˆHä˜A˜q !  a¡¨!¡™}¨aÓ0Ð0ùò =s   šA"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   r/   )r%   r#   rl   rk   r   )r6   rm   rB   r8   Úes        r>   Údmp_eval_tailrq   l  sd   € ñ$ Øˆä�!�QÔÜ˜œC ›F™
Ó#Ð#ä�q˜!˜Q  1Ó%€AàŒC�‹F�Q‰J‚Øˆä˜˜A¤ A£™JÓ'Ð'r@   c                 ó°   — ||k(  rt        t        | |||«      |||«      S |dz
  |dz   }}t        | D �cg c]  }t        |||||||«      ‘Œ c}|«      S c c}w )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   Œ  sb   € àˆA‚vÜœ  A q¨!Ó,¨a°°AÓ6Ð6àˆq‰5�!�a‘%€q€AäÀAÖG¸q”~ a¨¨A¨q°!°Q¸Õ:ÒGÈÓKÐKùÒGs   ³Ac           	      óŽ   — ||kD  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 < r\   r   )rK   re   rV   rs   )r6   r7   ra   r=   rB   r8   s         r>   Údmp_diff_eval_inrv   –  sS   € ð$ 	ˆ1‚uÝºQÂÁ1ÐEÓFÐFÙÜœ  A q¨!Ó,¨a°°AÓ6Ð6ä˜!˜Q  1 a¨¨AÓ.Ð.r@   c                 ó|  — |j                   rGg }| D ]5  }||z  }||dz  kD  r|j                  ||z
  «       Œ%|j                  |«       Œ7 t	        |«      S |j                  r7t        |«      }| D �cg c]  } |t        |«      |z  «      ‘Œ }}t	        |«      S | D �cg c]  }||z  ‘Œ	 }}t	        |«      S c c}w c c}w )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‘ˆAà�1˜‘6ŠzØ—‘˜˜Q™•à—‘˜•ð	ô �Q‹<Ðð 
×	Ò	ä�‹VˆØ&'Ö) ‰a”�A“˜‘�nÐ)ˆÐ)ô �Q‹<Ðð Ö ˜ˆa�!‹eÐ ˆÐ ä�Q‹<Ðùò	 *ùâ s   Á/B4ÂB9c                 ó^   — t        | D �cg c]  }t        |||dz
  |«      ‘Œ c}|«      S c c}w )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

    r/   )r   r   )r6   r|   rB   r8   r;   s        r>   Ú	dmp_truncr€   Ò  s.   € ô" ¸Ö;°1”w˜q ! Q¨¡U¨AÕ.Ò;¸QÓ?Ð?ùÒ;s   Š*c                 ó€   — |st        | ||«      S |dz
  }t        | D �cg c]  }t        ||||«      ‘Œ c}|«      S c c}w )a   
    Reduce a ``K[X]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

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

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

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

    r/   )r~   r   Údmp_ground_trunc)r6   r|   rB   r8   rC   r;   s         r>   r‚   r‚   æ  sF   € ñ  Ü˜˜A˜qÓ!Ð!à	ˆA‰€Aä¸QÖ@¸Ô'¨¨1¨a°Õ3Ò@À!ÓDÐDùÒ@s   ž;c                 ób   — | s| S t        | |«      }|j                  |«      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   )r6   r8   Úlcs      r>   Ú	dup_monicr†   þ  s6   € ñ$ Øˆä	��1‹€Bà‡x�x�„|Øˆä  2 qÓ)Ð)r@   c                 ó–   — |st        | |«      S t        | |«      r| S t        | ||«      }|j                  |«      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   )r6   rB   r8   r…   s       r>   Údmp_ground_monicrˆ     sQ   € ñ, Ü˜˜A‹Ðä�!�QÔØˆä	�q˜!˜QÓ	€Bà‡x�x�„|Øˆä  2 q¨!Ó,Ð,r@   c                 óà   — ddl m} | s|j                  S |j                  }||k(  r| D ]  }|j                  ||«      }Œ |S | D ](  }|j                  ||«      }|j	                  |«      sŒ' |S  |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‹   r0   Úgcdr„   )r6   r8   r‹   Úcontr;   s        r>   Údup_contentr�   ?  s‚   € õ, 'áØ�v‰vˆà�6‰6€DàˆB‚wØò 	"ˆAØ—5‘5˜˜q“>‰Dð	"ð €Kð ò 	ˆAØ—5‘5˜˜q“>ˆDà�x‰x˜�~Øà€Kð	ð €Kr@   c           	      óF  — ddl m} |st        | |«      S t        | |«      r|j                  S |j                  |dz
  }}||k(  r&| D ]  }|j                  |t        |||«      «      }Œ! |S | D ]3  }|j                  |t        |||«      «      }|j                  |«      sŒ2 |S  |S )aa  
    Compute the GCD of coefficients of ``f`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_ground_content(f)
    2

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

    >>> R.dmp_ground_content(f)
    2

    r   rŠ   r/   )rŒ   r‹   r�   r%   r0   r�   Údmp_ground_contentr„   )r6   rB   r8   r‹   rŽ   rC   r;   s          r>   r‘   r‘   i  s·   € õ, 'áÜ˜1˜aÓ Ð ä�!�QÔØ�v‰vˆà�f‰f�a˜!‘eˆ!€DàˆB‚wØò 	<ˆAØ—5‘5˜Ô1°!°Q¸Ó:Ó;‰Dð	<ð €Kð ò 	ˆAØ—5‘5˜Ô1°!°Q¸Ó:Ó;ˆDà�x‰x˜�~Øà€Kð	ð €Kr@   c                 ó‚   — | s|j                   | fS t        | |«      }|j                  |«      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)

    )r0   r�   r„   r   )r6   r8   rŽ   s      r>   Údup_primitiver“   –  sI   € ñ, Ø�v‰v�qˆyÐä�q˜!Ó€Dà‡x�x�„~Ø�Qˆwˆà”^ A t¨QÓ/Ð/Ð/r@   c                 ó¶   — |st        | |«      S t        | |«      r|j                  | fS t        | ||«      }|j	                  |«      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%   r0   r‘   r„   r   )r6   rB   r8   rŽ   s       r>   Údmp_ground_primitiver•   ·  sd   € ñ, Ü˜Q Ó"Ð"ä�!�QÔØ�v‰v�qˆyÐä˜a  AÓ&€Dà‡x�x�„~Ø�Qˆwˆà”^ A t¨Q°Ó2Ð2Ð2r@   c                 ó¶   — t        | |«      }t        ||«      }|j                  ||«      }|j                  |«      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   )r6   r9   r8   ÚfcÚgcr�   s         r>   Údup_extractr™   Û  s^   € ô 
�Q˜Ó	€BÜ	�Q˜Ó	€Bà
�%‰%��B‹-€Cà�8‰8�CŒ=Ü˜1˜c 1Ó%ˆÜ˜1˜c 1Ó%ˆà��1ˆ9Ðr@   c                 ó¾   — t        | ||«      }t        |||«      }|j                  ||«      }|j                  |«      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   )r6   r9   rB   r8   r—   r˜   r�   s          r>   Údmp_ground_extractr›   õ  sf   € ô 
˜A˜q !Ó	$€BÜ	˜A˜q !Ó	$€Bà
�%‰%��B‹-€Cà�8‰8�CŒ=Ü˜1˜c 1 aÓ(ˆÜ˜1˜c 1 aÓ(ˆà��1ˆ9Ðr@   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 ])  }t        ||d|«      }t        |t        |d«      dd|«      }Œ+ t        |«      }|j                  «       D ]Q  \  }}|dz  }	|	st        ||d|«      }Œ|	dk(  rt        ||d|«      }Œ0|	dk(  rt        ||d|«      }ŒDt        ||d|«      }ŒS ||fS )aý  
    Find ``f1`` and ``f2``, such that ``f(x+I*y) = f1(x,y) + f2(x,y)*I``.

    Examples
    ========

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

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

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

    z;computing real and imaginary parts is not supported over %sr/   r   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áØ�2ˆvˆà�5‰5�!—&‘&ˆ/Ð	˜aŸe™e˜W b˜MÐ*€AÜ�1�Q‘4˜Ó€AàˆqˆrˆUò 7ˆÜ�A�q˜!˜QÓˆÜ˜œJ q¨!Ó,¨a°°AÓ6‰ð7ô 	˜Ó€Aà—‘“	ò 
&‰ˆˆ1Ø�‰EˆáÜ˜˜Q  1Ó%‰BØ�!ŠVÜ˜˜Q  1Ó%‰BØ�!ŠVÜ˜˜Q  1Ó%‰Bä˜˜Q  1Ó%‰Bð
&ð ˆrˆ6€Mr@   c                 ój   — 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

    rx   rO   éþÿÿÿ)Úlistr3   rl   )r6   r8   r:   s      r>   Ú
dup_mirrorr¨   C  sC   € ô 	ˆQ‹€Aä”3�q“6˜A‘:˜r 2Ó&ò ˆØ�!‘ˆuˆˆ!Šðð €Hr@   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

    r/   rO   ©r§   rl   r3   )r6   ra   r8   r<   Úbr:   s         r>   Ú	dup_scaler¬   Y  s[   € ô �1‹g”s˜1“v ‘z 1ˆ!€q€Aä�1�q‘5˜"˜bÓ!ò ˆØ�A�a‘D‘&˜!˜A™#ˆˆˆ!‰‰aðð €Hr@   c                 óª   — t        | «      t        | «      dz
  }} t        |dd«      D ])  }t        d|«      D ]  }| |dz   xx   || |   z  z  cc<   Œ Œ+ | S )zç
    Evaluate efficiently Taylor shift ``f(x + a)`` in ``K[x]``.

    Examples
    ========

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

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

    r/   r   rO   rª   )r6   ra   r8   r<   r:   r=   s         r>   Ú	dup_shiftr®   o  sf   € ô �‹7”C˜“F˜Q‘J€q€Aä�1�a˜‹_ò ˆÜ�q˜!“ò 	ˆAØˆa�!‰e‹H˜˜!˜A™$™ÑŒHñ	ðð €Hr@   c           	      óª  — |st        | |d   |«      S t        | |«      r| S |d   |dd }}t        |«      r| D �cg c]  }t        |||dz
  |«      ‘Œ } }nt	        | «      } |rbt        | «      dz
  }t        |dd«      D ]D  }t        d|«      D ]3  }	t        | |	   ||dz
  |«      }
t        | |	dz      |
|dz
  |«      | |	dz   <   Œ5 ŒF t        | |«      S c c}w )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˜a™D !Ó$Ð$ä�!�QÔØˆàˆq‰T�1�Q�R�5ˆ€Bä
ˆ2„wØ01Ö3¨1Œi˜˜2˜q ™s AÕ&Ð3ˆÑ3ä�‹Gˆá	Ü�‹F�Q‰Jˆä�q˜!˜R“ò 	:ˆAÜ˜1˜a“[ò :�Ü$ Q q¡T¨2¨q°©s°AÓ6�Ü" 1 Q¨¡U¡8¨S°!°A±#°qÓ9��!�a‘%’ñ:ð	:ô
 �Q˜‹?Ðùò 4s   ºCc                 ó4  — | sg S t        | «      dz
  }| d   g|j                  gg}}t        d|«      D ]!  }|j                  t	        |d   ||«      «       Œ# t        | dd |dd «      D ],  \  }}t	        |||«      }t        |||«      }t        |||«      }Œ. |S )a  
    Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``.

    Examples
    ========

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

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

    r/   r   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€Aä�1�a‹[ò 'ˆØ	�‰”˜˜2™  1Ó%Õ&ð'ô �A�a�b�E˜1˜Q˜R˜5Ó!ò ‰ˆˆ1Ü�A�q˜!ÓˆÜ˜1˜a Ó#ˆÜ�A�q˜!Ó‰ðð
 €Hr@   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

    r/   r   N)rl   r   rc   r   r
   r   )r6   r9   r8   rn   r;   s        r>   Údup_composer»   Ð  sy   € ô ˆ1ƒv�‚{Üœ( 1¤f¨Q°£l°AÓ6Ð7Ó8Ð8áØˆ	à	
ˆ1‰ˆ€AàˆqˆrˆUò %ˆÜ�A�q˜!ÓˆÜ˜˜A˜q !Ó$‰ð%ð €Hr@   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   r/   N)r»   r%   r   r   )r6   r9   rB   r8   rn   r;   s         r>   Údmp_composer½   í  sn   € ñ Ü˜1˜a Ó#Ð#ä�!�QÔØˆà	
ˆ1‰ˆ€AàˆqˆrˆUò (ˆÜ�A�q˜!˜QÓˆÜ˜˜A˜q ! QÓ'‰ð(ð €Hr@   c                 ó�  — t        | «      dz
  }t        | |«      }t        | «      } ||j                  i}||z  }t	        d|«      D ]t  }|j
                  }t	        d|«      D ]9  }	||	z   |z
  | vrŒ||	z
  |vrŒ| ||	z   |z
     |||	z
     }}
||||	z  z
  |
z  |z  z  }Œ; |j                  |||z  |z  «      |||z
  <   Œv t        ||«      S )ú+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Ü	��1‹€Bä˜Ó€AØ
ˆQ�U‰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ð	%ð —5‘5˜  !¡ B¡Ó'ˆˆ!ˆa‰%Šð(ô ˜Q Ó"Ð"r@   c                 ó–   — i d}}| r8t        | ||«      \  }}t        |«      dkD  ryt        ||«      ||<   ||dz   }} | rŒ8t        ||«      S )r¿   r   Nr/   )r   r   r   r'   )r6   rn   r8   r9   r:   r·   rÂ   s          r>   Ú_dup_left_decomposerÅ   &  s_   € àˆq€q€Aá
Ü�q˜!˜QÓ‰ˆˆ1ä�a‹=˜1ÒØä˜!˜Q“<ˆAˆa‰DØ�a˜!‘eˆqˆAò ô ˜Q Ó"Ð"r@   c                 óž   — t        | «      dz
  }t        d|«      D ]0  }||z  dk7  rŒt        | ||«      }|€Œt        | ||«      }|€Œ,||fc S  y)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  sf   € ä	ˆQ‹�!‰€Bä�1�b‹\ò 
ˆØ�‰6�QŠ;Øä   A qÓ)ˆà‰=Ü# A q¨!Ó,ˆAà‰}Ø˜!�t’ð
ð r@   c                 óL   — 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È   )r6   r8   ÚFrb   rn   s        r>   Údup_decomposerË   I  sH   € ðH 	€Aà
Ü  1Ó%ˆàÐØ‰DˆAˆqØ��a‘‰Aàð ð ˆ3�‰7€Nr@   c                 ó”   — |j                   s|j                  rt        | ||«      S |j                  rt	        | ||«      S t        d«      ‚)a…  
    Convert polynomial from ``K(a)[X]`` to ``K[a,X]``.

    Examples
    ========

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

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

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

    z3computation can be done only in an algebraic domain)Úis_GaussianRingÚis_GaussianFieldÚ_dmp_alg_inject_gaussianÚis_AlgebraicÚ_dmp_alg_inject_algr+   )r6   rB   r8   s      r>   Údmp_alg_injectrÒ   {  sF   € ð, 	×Ò˜A×.Ò.Ü'¨¨1¨aÓ0Ð0Ø	
�ŠÜ" 1 a¨Ó+Ð+äÐOÓPÐPr@   c                 ó   — t        | |«      i }} | j                  «       D ]2  \  }}|j                  |j                  }}|r||d|z   <   |sŒ+||d|z   <   Œ4 t	        ||dz   |j
                  «      }||dz   |j
                  fS )ú+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Ï   ™  sŠ   € ä�q˜!Ó˜b€q€Aà—g‘g“iò "‰
ˆ�Ø�s‰s�A—C‘Cˆ1ˆÙØ !ˆAˆd�W‰nÑÚØ !ˆAˆd�W‰nÒð"ô 	�a˜˜Q™ §¡Ó&€Aàˆa�!‰e�Q—U‘Uˆ?Ðr@   c                 ó  — t        | |«      i }} | j                  «       D ]3  \  }}|j                  «       j                  «       D ]  \  }}||||z   <   Œ Œ5 t        ||dz   |j                  «      }||dz   |j                  fS )rÔ   r/   )r   r    Úto_dictr   r×   )	r6   rB   r8   rn   rØ   r9   Úg_monomr;   rÊ   s	            r>   rÑ   rÑ   ©  sˆ   € ä�q˜!Ó˜b€q€Aà—g‘g“iò %‰
ˆ�ØŸ)™)›+×+Ñ+Ó-ò 	%‰JˆG�QØ#$ˆAˆg˜ÑÒ ñ	%ð%ô 	�a˜˜Q™ §¡Ó&€Aàˆa�!‰e�Q—U‘Uˆ?Ðr@   c           
      óÂ   — ddl m} t        | ||«      \  }}}|j                  j	                  «       }t        |t        t        d|dz   «      «      d|«      } |||||«      S )aO  
    Convert algebraic coefficients to integers in ``K[X]``.

    Examples
    ========

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

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

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

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

    r/   )Údmp_resultantr   )ÚeuclidtoolsrÝ   rÒ   ÚmodÚto_listr)   r§   r3   )	r6   rB   r8   rÝ   rÊ   rC   ÚK2Úp_aÚP_As	            r>   Údmp_lifträ   ¶  sZ   € õ( +ä˜a  AÓ&�H€A€qˆ"à
�%‰%�-‰-‹/€CÜ
�cœ4¤ a¨¨Q©£Ó0°!°RÓ
8€Cá˜˜C  BÓ'Ð'r@   c                 óh  ‡— ˆfd„}‰j                   s‰j                  s‰j                  r‰j                  }nÐ‰j                  r‰j
                  j                  r|}n«‰j                  s‰j                  r…t        ‰j                  «      dk(  rm‰j                  j                   s"‰j                  j                  s‰j                  r5‰j                  d   j                  r‰j                  d   j                  r|}nt        d‰z  «      ‚‰j                  d}}| D ]  } |||z  «      r|dz  }|sŒ|}Œ |S )zâ
    Compute the number of sign variations of ``f`` in ``K[x]``.

    Examples
    ========

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

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

    c                 óD   •— | syt        ‰j                  | «      dk  «      S )NFr   )ÚboolÚto_sympy)ra   r8   s    €r>   Úis_negative_sympyz.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ˆ!€Dàò ˆÙ�u˜T‘zÔ"Ø�‰FˆAâØ‰Dðð €Hr@   Nc           
      ó¬  — |€|j                   r|j                  «       }n|}|j                  }| D ]#  }|j                  ||j	                  |«      «      }Œ% |j                  |«      r|s|| fS |t        | ||«      fS | D �cg c]5  }|j                  |«      |j                  ||j	                  |«      «      z  ‘Œ7 } }|s|t        | ||«      fS || fS c c}w )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�ÔÙØ˜1�9Ðàœ; q¨"¨bÓ1Ð1Ð1ð ;<Ö<°Qˆ�‰�!‹�R—V‘V˜F B§H¡H¨Q£KÓ0Ó	0Ð<€AÐ<áØ”{ 1 b¨"Ó-Ð-Ð-à�qˆyÐùò 	=s   Â :Cc           
      óÊ   — |j                   }|s*| D ]#  }|j                  ||j                  |«      «      }Œ% |S |dz
  }| D ]   }|j                  |t        ||||«      «      }Œ" |S )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  s{   € à�V‰V€FáØò 	1ˆAØ—V‘V˜F B§H¡H¨Q£KÓ0‰Fð	1ð €Mð �‰Eˆàò 	EˆAØ—V‘V˜FÔ$5°a¸¸BÀÓ$CÓD‰Fð	Eð €Mr@   c                 óì   — |st        | |||¬«      S |€|j                  r|j                  «       }n|}t        | |||«      }|j	                  |«      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)

    )r`   )rþ   rö   r÷   r   r„   r   r   )r6   rB   rû   rü   r`   rý   s         r>   Údmp_clear_denomsr  H  s…   € ñ$ Ü  2 r°7Ô;Ð;à	€zØ×ÒØ—‘“‰BàˆBä˜q ! R¨Ó,€Fà�9‰9�VÔÜ˜1˜f a¨Ó,ˆáØ�qˆyÐà”{ 1 a¨¨RÓ0Ð0Ð0r@   c                 ó–  — |j                  t        | |«      «      g}|j                  |j                  |j                  g}t	        t        t        |«      «      «      }t        d|dz   «      D ]Z  }t        | |d«      |«      }t        | t        ||«      |«      }t        t        |||«      ||«      }t        |t        |«      |«      }Œ\ |S )a÷  
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

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

    Examples
    ========

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

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

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

    r/   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Ø	
�‰�—‘˜Ÿ™Ð€AäŒE”%˜“(‹OÓ€Aä�1�a˜!‘e‹_ò ,ˆÜ˜1™a ›d AÓ&ˆÜ�A”w˜q !“} aÓ(ˆÜ”G˜A˜q !Ó$ a¨Ó+ˆÜ�qœ* Q›-¨Ó+‰ð	,ð €Hr@   c                 ó8   — |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*   )r6   r9   rB   r8   s       r>   Ú
dmp_revertr
  �  s#   € ñ Ü˜!˜Q Ó"Ð"ä)¨!¨QÓ/Ð/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@   