§
    OŠtj2t  ã                   ó   — 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]d9d4„Z^d5„ Z_d9d6„Z`d7„ Zad8„ Zbd2S ):zHAdvanced 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 ][\  }}|dz   }t          d|¦  «        D ]}|||z   dz   z  }Œ|                     d|                     | ||¦  «        ¦  «        ¦  «         Œ\|S )a  
    Computes the indefinite integral of ``f`` in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_integrate(x**2 + 2*x, 1)
    1/3*x**3 + x**2
    >>> R.dup_integrate(x**2 + 2*x, 2)
    1/12*x**4 + 1/3*x**3

    r   é   )ÚzeroÚ	enumerateÚreversedÚrangeÚinsertÚexquo)ÚfÚmÚKÚgÚiÚcÚnÚjs           úT/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/polys/densetools.pyÚdup_integrater?   '   s©   € ð  	ˆA‚v€v�Q€vØˆà	
Œˆ�‰
€Aå�( 1™+œ+Ñ&Ô&ð &ð &‰ˆˆ1Ø�‰Eˆå�q˜!‘”ð 	ð 	ˆAØ��Q‘˜‘‰NˆAˆAà	�Š��A—G’G˜A˜q˜q ™tœtÑ$Ô$Ñ%Ô%Ð%Ð%à€Hó    c           
      óv  — |st          | ||¦  «        S |dk    st          | |¦  «        r| S t          ||dz
  |¦  «        |dz
  }}t          t	          | ¦  «        ¦  «        D ]W\  }}|dz   }t          d|¦  «        D ]}	|||	z   dz   z  }Œ|                     dt          | ||¦  «        ||¦  «        ¦  «         ŒX|S )a&  
    Computes the indefinite integral of ``f`` in ``x_0`` in ``K[X]``.

    Examples
    ========

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

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

    r   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€v•˜A˜qÑ!Ô!€vØˆå�Q˜˜A™˜qÑ!Ô! 1 q¡5€q€Aå�( 1™+œ+Ñ&Ô&ð 3ð 3‰ˆˆ1Ø�‰Eˆå�q˜!‘”ð 	ð 	ˆAØ��Q‘˜‘‰NˆAˆAà	�Š�•N 1 a a¨¡d¤d¨A¨qÑ1Ô1Ñ2Ô2Ð2Ð2à€Hr@   c                 ó’   ‡‡‡‡‡— ‰‰k    rt          | ‰|‰¦  «        S |dz
  ‰dz   cŠŠt          ˆˆˆˆˆfd„| D ¦   «         |¦  «        S )z.Recursive helper for :func:`dmp_integrate_in`.r/   c           
      ó8   •— g | ]}t          |‰‰‰‰‰¦  «        ‘ŒS © )Ú_rec_integrate_in©Ú.0r;   r8   r:   r=   r7   Úws     €€€€€r>   ú
<listcomp>z%_rec_integrate_in.<locals>.<listcomp>q   s,   ø€ ÐGÐGÐG¸qÕ(¨¨A¨q°!°Q¸Ñ:Ô:ÐGÐGÐGr@   )rD   r   ©r9   r7   rC   r:   r=   r8   rK   s    ` ```@r>   rH   rH   j   sh   øøøøø€ àˆA‚v€vÝ˜Q  1 aÑ(Ô(Ð(àˆq‰5�!�a‘%€D€A€qåÐGÐGÐGÐGÐGÐGÐGÐGÀAÐGÑGÔGÈÑKÔKÐKr@   c                 ój   — |dk     s||k    rt          d||fz  ¦  «        ‚t          | ||d||¦  «        S )a+  
    Computes the indefinite integral of ``f`` in ``x_j`` in ``K[X]``.

    Examples
    ========

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

    >>> R.dmp_integrate_in(x + 2*y, 1, 0)
    1/2*x**2 + 2*x*y
    >>> R.dmp_integrate_in(x + 2*y, 1, 1)
    x*y + y**2

    r   z(0 <= j <= u expected, got u = %d, j = %d)Ú
IndexErrorrH   ©r6   r7   r=   rB   r8   s        r>   Údmp_integrate_inrQ   t   sE   € ð  	ˆ1‚u€u��A’�ÝÐCÀqÈ!ÀfÑLÑMÔMÐMå˜Q  1 a¨¨AÑ.Ô.Ð.r@   c                 ó‚  — |dk    r| S t          | ¦  «        }||k     rg S g }|dk    r5| d| …         D ](}|                      ||¦  «        |z  ¦  «         |dz  }Œ)nU| d| …         D ]I}|}t          |dz
  ||z
  d¦  «        D ]}||z  }Œ|                      ||¦  «        |z  ¦  «         |dz  }ŒJt          |¦  «        S )a#  
    ``m``-th order derivative of a polynomial in ``K[x]``.

    Examples
    ========

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

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

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

    Examples
    ========

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

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

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

    r   r/   NrS   )rX   r   r#   rT   r   r3   r   )
r6   r7   rB   r8   r<   rU   rC   rV   rW   r:   s
             r>   Údmp_diffrZ   µ   sH  € ð$ ð !Ý˜˜1˜aÑ Ô Ð ØˆA‚v€vØˆå�1�aÑÔ€Aàˆ1‚u€uÝ˜‰{Œ{Ðà�1�q‘5ˆ1€EàˆA‚v€vØ�s˜˜�s”Vð 	ð 	ˆEØ�LŠL�¨¨q¨q°©t¬t°Q¸Ñ:Ô:Ñ;Ô;Ð;Ø�‰FˆAˆAð	ð �s˜˜�s”Vð 	ð 	ˆEØˆAå˜1˜q™5 ! a¡%¨Ñ,Ô,ð ð �Ø�Q‘��à�LŠL�¨¨q¨q°©t¬t°Q¸Ñ:Ô:Ñ;Ô;Ð;Ø�‰FˆAˆAå�U˜AÑÔÐr@   c                 ó’   ‡‡‡‡‡— ‰‰k    rt          | ‰|‰¦  «        S |dz
  ‰dz   cŠŠt          ˆˆˆˆˆfd„| D ¦   «         |¦  «        S )z)Recursive helper for :func:`dmp_diff_in`.r/   c           
      ó8   •— g | ]}t          |‰‰‰‰‰¦  «        ‘ŒS rG   )Ú_rec_diff_inrI   s     €€€€€r>   rL   z _rec_diff_in.<locals>.<listcomp>ë   ó+   ø€ ÐBÐBÐB¸!•| A q¨!¨Q°°1Ñ5Ô5ÐBÐBÐBr@   )rZ   r   rM   s    ` ```@r>   r]   r]   ä   óh   øøøøø€ àˆA‚v€vÝ˜˜1˜a Ñ#Ô#Ð#àˆq‰5�!�a‘%€D€A€qåÐBÐBÐBÐBÐBÐBÐBÐB¸qÐBÑBÔBÀAÑFÔFÐFr@   c                 ól   — |dk     s||k    rt          d|›d|›�¦  «        ‚t          | ||d||¦  «        S )aS  
    ``m``-th order derivative in ``x_j`` of a polynomial in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_diff_in(f, 1, 0)
    y**2 + 2*y + 3
    >>> R.dmp_diff_in(f, 1, 1)
    2*x*y + 2*x + 4*y + 3

    r   ú
0 <= j <= ú expected, got )rO   r]   rP   s        r>   Údmp_diff_inrc   î   óH   € ð$ 	ˆ1‚u€u��A’�Ýˆj¸A¸A¸A¸q¸qÐAÑBÔBÐBå˜˜1˜a  A qÑ)Ô)Ð)r@   c                 ó|   — |s#|                      t          | |¦  «        ¦  «        S |j        }| D ]}||z  }||z  }Œ|S )zÞ
    Evaluate a polynomial at ``x = a`` in ``K[x]`` using Horner scheme.

    Examples
    ========

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

    >>> R.dup_eval(x**2 + 2*x + 3, 2)
    11

    )Úconvertr!   r0   )r6   Úar8   Úresultr;   s        r>   Údup_evalri     sU   € ð ð 'Ø�yŠy�  1™œÑ&Ô&Ð&àŒ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)ri   r"   r   r   r   )r6   rg   rB   r8   rh   rC   rV   s          r>   Údmp_evalrk      s�   € ð ð !Ý˜˜1˜aÑ Ô Ð àð Ý�a˜‰|Œ|Ðå�q˜!‘”˜a !™eˆA€Fà�1�2�2”ð .ð .ˆÝ ¨¨1¨aÑ0Ô0ˆÝ˜ ¨¨1Ñ-Ô-ˆˆà€Mr@   c                 ó’   ‡‡‡‡‡— ‰‰k    rt          | ‰‰‰¦  «        S ‰dz
  ‰dz   cŠŠt          ˆˆˆˆˆfd„| D ¦   «         ‰¦  «        S )z)Recursive helper for :func:`dmp_eval_in`.r/   c           
      ó8   •— g | ]}t          |‰‰‰‰‰¦  «        ‘ŒS rG   )Ú_rec_eval_in)rJ   r;   r8   rg   r:   r=   rC   s     €€€€€r>   rL   z _rec_eval_in.<locals>.<listcomp>D  r^   r@   )rk   r   )r9   rg   rC   r:   r=   r8   s    `````r>   rn   rn   =  r_   r@   c                 ól   — |dk     s||k    rt          d|›d|›�¦  «        ‚t          | ||d||¦  «        S )a2  
    Evaluate a polynomial at ``x_j = a`` in ``K[X]`` using the Horner scheme.

    Examples
    ========

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

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

    >>> R.dmp_eval_in(f, 2, 0)
    5*y + 8
    >>> R.dmp_eval_in(f, 2, 1)
    7*x + 4

    r   ra   rb   )rO   rn   )r6   rg   r=   rB   r8   s        r>   Údmp_eval_inrp   G  rd   r@   c                 óØ   ‡‡‡‡— ‰‰k    rt          | ‰d         ‰¦  «        S ˆˆˆˆfd„| D ¦   «         }‰‰t          ‰¦  «        z
  dz   k     r|S t          |‰‰ ‰z   dz
           ‰¦  «        S )z+Recursive helper for :func:`dmp_eval_tail`.rS   c           	      ó<   •— g | ]}t          |‰d z   ‰‰‰¦  «        ‘ŒS ©r/   )Ú_rec_eval_tail)rJ   r;   ÚAr8   r:   rB   s     €€€€r>   rL   z"_rec_eval_tail.<locals>.<listcomp>d  s-   ø€ Ð<Ð<Ð<°A�n˜Q  A¡ q¨!¨QÑ/Ô/Ð<Ð<Ð<r@   r/   )ri   Úlen)r9   r:   ru   rB   r8   Úhs    ```` r>   rt   rt   _  s…   øøøø€ àˆA‚v€vÝ˜˜1˜Rœ5 !Ñ$Ô$Ð$à<Ð<Ð<Ð<Ð<Ð<Ð<¸Ð<Ñ<Ô<ˆàˆq•3�q‘6”6‰z˜A‰~ÒÐØˆHå˜A˜q !  a¡¨!¡œ}¨aÑ0Ô0Ð0r@   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#   rv   rt   r   )r6   ru   rB   r8   Úes        r>   Údmp_eval_tailrz   l  s‚   € ð$ ð Øˆå�!�QÑÔð $Ý˜�C ™FœF™
Ñ#Ô#Ð#å�q˜!˜Q  1Ñ%Ô%€Aà�C�‰FŒF�Q‰J‚€Øˆå˜˜A¥ A¡¤™JÑ'Ô'Ð'r@   c                 ó¶   ‡‡‡‡‡‡— ‰‰k    r"t          t          | ‰‰‰¦  «        ‰‰‰¦  «        S ‰dz
  ‰dz   cŠŠt          ˆˆˆˆˆˆfd„| D ¦   «         ‰¦  «        S )z+Recursive helper for :func:`dmp_diff_eval`.r/   c                 ó:   •— g | ]}t          |‰‰‰‰‰‰¦  «        ‘ŒS rG   )Ú_rec_diff_eval)rJ   r;   r8   rg   r:   r=   r7   rC   s     €€€€€€r>   rL   z"_rec_diff_eval.<locals>.<listcomp>“  s-   ø€ ÐGÐGÐG¸q•~ a¨¨A¨q°!°Q¸Ñ:Ô:ÐGÐGÐGr@   )rk   rZ   r   )r9   r7   rg   rC   r:   r=   r8   s    ``````r>   r}   r}   Œ  sz   øøøøøø€ àˆA‚v€vÝ�  A q¨!Ñ,Ô,¨a°°AÑ6Ô6Ð6àˆq‰5�!�a‘%€D€A€qåÐGÐGÐGÐGÐGÐGÐGÐGÐGÀAÐGÑGÔGÈÑKÔKÐKr@   c           	      ó°   — ||k    rt          d|›d|›d|›�¦  «        ‚|s"t          t          | |||¦  «        |||¦  «        S t          | |||d||¦  «        S )a]  
    Differentiate and evaluate a polynomial in ``x_j`` at ``a`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_diff_eval_in(f, 1, 2, 0)
    y**2 + 2*y + 3
    >>> R.dmp_diff_eval_in(f, 1, 2, 1)
    6*x + 11

    ú-z <= j < rb   r   )rO   rk   rZ   r}   )r6   r7   rg   r=   rB   r8   s         r>   Údmp_diff_eval_inr€   –  sr   € ð$ 	ˆ1‚u€uÝˆj¸Q¸Q¸QÀÀÀÀ1À1ÐEÑFÔFÐFØð 7Ý�  A q¨!Ñ,Ô,¨a°°AÑ6Ô6Ð6å˜!˜Q  1 a¨¨AÑ.Ô.Ð.r@   c                 ó$  ‡‡‡— ‰j         rDg }| D ]>}|‰z  }|‰dz  k    r|                     |‰z
  ¦  «         Œ)|                     |¦  «         Œ?n4‰j        rt          ‰¦  «        Šˆˆfd„| D ¦   «         }nˆfd„| D ¦   «         }t	          |¦  «        S )zô
    Reduce a ``K[x]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

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

    >>> R.dup_trunc(2*x**3 + 3*x**2 + 5*x + 7, ZZ(3))
    -x**3 - x + 1

    é   c                 óF   •— g | ]} ‰t          |¦  «        ‰z  ¦  «        ‘ŒS rG   )Úint)rJ   r;   r8   Úpis     €€r>   rL   zdup_trunc.<locals>.<listcomp>Ë  s+   ø€ Ð)Ð)Ð) ˆaˆa•�A‘”˜‘‰nŒnÐ)Ð)Ð)r@   c                 ó   •— g | ]}|‰z  ‘ŒS rG   rG   )rJ   r;   Úps     €r>   rL   zdup_trunc.<locals>.<listcomp>Í  s   ø€ Ð Ð Ð ˜ˆa�!‰eÐ Ð Ð r@   )Úis_ZZrT   Úis_FiniteFieldr„   r   )r6   r‡   r8   r9   r;   r…   s    ``  @r>   Ú	dup_truncrŠ   °  sÁ   øøø€ ð 	„wð !Øˆàð 	ð 	ˆAØ�A‘ˆAà�1˜‘6ŠzˆzØ—’˜˜Q™‘”��à—’˜‘”��ð	ð 
Ô	ð !å�‰VŒVˆØ)Ð)Ð)Ð)Ð) aÐ)Ñ)Ô)ˆˆà Ð Ð Ð ˜QÐ Ñ Ô ˆå�Q‰<Œ<Ðr@   c                 óD   ‡‡‡— t          ˆˆˆfd„| D ¦   «         ‰¦  «        S )a9  
    Reduce a ``K[X]`` polynomial modulo a polynomial ``p`` in ``K[Y]``.

    Examples
    ========

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

    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3
    >>> g = (y - 1).drop(x)

    >>> R.dmp_trunc(f, g)
    11*x**2 + 11*x + 5

    c                 ó:   •— g | ]}t          |‰‰d z
  ‰¦  «        ‘ŒS rs   )r   )rJ   r;   r8   r‡   rB   s     €€€r>   rL   zdmp_trunc.<locals>.<listcomp>ã  s+   ø€ Ð;Ð;Ð;°1•w˜q ! Q¨¡U¨AÑ.Ô.Ð;Ð;Ð;r@   )r   )r6   r‡   rB   r8   s    ```r>   Ú	dmp_truncr�   Ò  s2   øøø€ õ" Ð;Ð;Ð;Ð;Ð;Ð;¸Ð;Ñ;Ô;¸QÑ?Ô?Ð?r@   c                 ót   ‡‡‡— |st          | ‰‰¦  «        S |dz
  Št          ˆˆˆfd„| D ¦   «         |¦  «        S )a   
    Reduce a ``K[X]`` polynomial modulo a constant ``p`` in ``K``.

    Examples
    ========

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

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

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

    r/   c                 ó4   •— g | ]}t          |‰‰‰¦  «        ‘ŒS rG   )Údmp_ground_trunc)rJ   r;   r8   r‡   rC   s     €€€r>   rL   z$dmp_ground_trunc.<locals>.<listcomp>û  s(   ø€ Ð@Ð@Ð@¸Õ'¨¨1¨a°Ñ3Ô3Ð@Ð@Ð@r@   )rŠ   r   )r6   r‡   rB   r8   rC   s    ` `@r>   r�   r�   æ  sU   øøø€ ð  ð "Ý˜˜A˜qÑ!Ô!Ð!à	ˆA‰€AåÐ@Ð@Ð@Ð@Ð@Ð@¸QÐ@Ñ@Ô@À!ÑDÔDÐDr@   c                 óz   — | s| S t          | |¦  «        }|                     |¦  «        r| S t          | ||¦  «        S )a7  
    Divide all coefficients by ``LC(f)`` in ``K[x]``.

    Examples
    ========

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

    >>> R, x = ring("x", ZZ)
    >>> R.dup_monic(3*x**2 + 6*x + 9)
    x**2 + 2*x + 3

    >>> R, x = ring("x", QQ)
    >>> R.dup_monic(3*x**2 + 4*x + 2)
    x**2 + 4/3*x + 2/3

    )r   Úis_oner   )r6   r8   Úlcs      r>   Ú	dup_monicr”   þ  sG   € ð$ ð Øˆå	��1‰Œ€Bà‡x‚x��|„|ð *Øˆå  2 qÑ)Ô)Ð)r@   c                 ó¾   — |st          | |¦  «        S t          | |¦  «        r| S t          | ||¦  «        }|                     |¦  «        r| S t	          | |||¦  «        S )aÃ  
    Divide all coefficients by ``LC(f)`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_ground_monic(f)
    x**2*y + 2*x**2 + x*y + 3*y + 1

    >>> R, x,y = ring("x,y", QQ)
    >>> f = 3*x**2*y + 8*x**2 + 5*x*y + 6*x + 2*y + 3

    >>> R.dmp_ground_monic(f)
    x**2*y + 8/3*x**2 + 5/3*x*y + 2*x + 2/3*y + 1

    )r”   r%   r    r’   r   )r6   rB   r8   r“   s       r>   Údmp_ground_monicr–     sm   € ð, ð Ý˜˜A‰ŒÐå�!�QÑÔð Øˆå	�q˜!˜QÑ	Ô	€Bà‡x‚x��|„|ð -Øˆå  2 q¨!Ñ,Ô,Ð,r@   c                 óÚ   — ddl m} | s|j        S |j        }||k    r| D ]}|                     ||¦  «        }Œn2| D ]/}|                     ||¦  «        }|                     |¦  «        r nŒ0|S )aA  
    Compute the GCD of coefficients of ``f`` in ``K[x]``.

    Examples
    ========

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

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

    >>> R.dup_content(f)
    2

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

    >>> R.dup_content(f)
    2

    r   ©ÚQQ)Úsympy.polys.domainsr™   r0   Úgcdr’   )r6   r8   r™   Úcontr;   s        r>   Údup_contentr�   ?  s¡   € ð, 'Ð&Ð&Ð&Ð&Ð&àð ØŒvˆàŒ6€DàˆB‚w€wØð 	"ð 	"ˆAØ—5’5˜˜q‘>”>ˆDˆDð	"ð ð 	ð 	ˆAØ—5’5˜˜q‘>”>ˆDà�xŠx˜‰~Œ~ð Ø�ðð €Kr@   c           	      ó`  — ddl m} |st          | |¦  «        S t          | |¦  «        r|j        S |j        |dz
  }}||k    r+| D ]'}|                     |t          |||¦  «        ¦  «        }Œ(nA| D ]>}|                     |t          |||¦  «        ¦  «        }|                     |¦  «        r nŒ?|S )aa  
    Compute the GCD of coefficients of ``f`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_ground_content(f)
    2

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

    >>> R.dmp_ground_content(f)
    2

    r   r˜   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ˆàŒf�a˜!‘eˆ!€DàˆB‚w€wØð 	<ð 	<ˆAØ—5’5˜Õ1°!°Q¸Ñ:Ô:Ñ;Ô;ˆDˆDð	<ð ð 	ð 	ˆAØ—5’5˜Õ1°!°Q¸Ñ:Ô:Ñ;Ô;ˆDà�xŠx˜‰~Œ~ð Ø�ðð €Kr@   c                 ó�   — | s	|j         | fS t          | |¦  «        }|                     |¦  «        r|| fS |t          | ||¦  «        fS )at  
    Compute content and the primitive form of ``f`` in ``K[x]``.

    Examples
    ========

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

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

    >>> R.dup_primitive(f)
    (2, 3*x**2 + 4*x + 6)

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

    >>> R.dup_primitive(f)
    (2, 3*x**2 + 4*x + 6)

    )r0   r�   r’   r   )r6   r8   rœ   s      r>   Údup_primitiver¡   –  sY   € ð, ð ØŒv�qˆyÐå�q˜!ÑÔ€Dà‡x‚x��~„~ð 0Ø�Qˆwˆà•^ A t¨QÑ/Ô/Ð/Ð/r@   c                 óÔ   — |st          | |¦  «        S t          | |¦  «        r	|j        | fS t          | ||¦  «        }|                     |¦  «        r|| fS |t          | |||¦  «        fS )aš  
    Compute content and the primitive form of ``f`` in ``K[X]``.

    Examples
    ========

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

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

    >>> R.dmp_ground_primitive(f)
    (2, x*y + 3*x + 2*y + 6)

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

    >>> R.dmp_ground_primitive(f)
    (2, x*y + 3*x + 2*y + 6)

    )r¡   r%   r0   rŸ   r’   r   )r6   rB   r8   rœ   s       r>   Údmp_ground_primitiver£   ·  s   € ð, ð #Ý˜Q Ñ"Ô"Ð"å�!�QÑÔð ØŒv�qˆyÐå˜a  AÑ&Ô&€Dà‡x‚x��~„~ð 3Ø�Qˆwˆà•^ A t¨Q°Ñ2Ô2Ð2Ð2r@   c                 óæ   — t          | |¦  «        }t          ||¦  «        }|                     ||¦  «        }|                     |¦  «        s"t          | ||¦  «        } t          |||¦  «        }|| |fS )a  
    Extract common content from a pair of polynomials in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_extract(6*x**2 + 12*x + 18, 4*x**2 + 8*x + 12)
    (2, 3*x**2 + 6*x + 9, 2*x**2 + 4*x + 6)

    )r�   r›   r’   r   )r6   r9   r8   ÚfcÚgcr›   s         r>   Údup_extractr§   Û  ss   € õ 
�Q˜Ñ	Ô	€BÝ	�Q˜Ñ	Ô	€Bà
�%Š%��B‰-Œ-€Cà�8Š8�C‰=Œ=ð &Ý˜1˜c 1Ñ%Ô%ˆÝ˜1˜c 1Ñ%Ô%ˆà��1ˆ9Ðr@   c                 óî   — t          | ||¦  «        }t          |||¦  «        }|                     ||¦  «        }|                     |¦  «        s$t          | |||¦  «        } t          ||||¦  «        }|| |fS )a  
    Extract common content from a pair of polynomials in ``K[X]``.

    Examples
    ========

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

    >>> R.dmp_ground_extract(6*x*y + 12*x + 18, 4*x*y + 8*x + 12)
    (2, 3*x*y + 6*x + 9, 2*x*y + 4*x + 6)

    )rŸ   r›   r’   r   )r6   r9   rB   r8   r¥   r¦   r›   s          r>   Údmp_ground_extractr©   õ  s{   € õ 
˜A˜q !Ñ	$Ô	$€BÝ	˜A˜q !Ñ	$Ô	$€Bà
�%Š%��B‰-Œ-€Cà�8Š8�C‰=Œ=ð )Ý˜1˜c 1 aÑ(Ô(ˆÝ˜1˜c 1 aÑ(Ô(ˆà��1ˆ9Ð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 ]5}t          ||d|¦  «        }t          |t          |d¦  «        dd|¦  «        }Œ6t          |¦  «        }| 
                    ¦   «         D ]c\  }}|dz  }	|	st          ||d|¦  «        }Œ|	dk    rt          ||d|¦  «        }Œ8|	dk    rt          ||d|¦  «        }ŒQt          ||d|¦  «        }Œd||fS )aý  
    Find ``f1`` and ``f2``, such that ``f(x+I*y) = f1(x,y) + f2(x,y)*I``.

    Examples
    ========

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

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

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

    z;computing real and imaginary parts is not supported over %sr/   r   r‚   Né   )rˆ   Úis_QQr+   r#   Úoner0   r$   r   r   r&   Úitemsr   r	   )
r6   r8   Úf1Úf2r9   rw   r;   ÚHrW   r7   s
             r>   Údup_real_imagr²     sx  € ð& Œ7ð ]˜1œ7ð ]ÝÐWÐZ[Ñ[Ñ\Ô\Ð\å	�!‰Œ€BÝ	�!‰Œ€Bàð Ø�2ˆvˆàŒ5�!”&ˆ/Ð	˜aœe˜W b˜MÐ*€AÝ�1�Q”4˜ÑÔ€AàˆqˆrˆrŒUð 7ð 7ˆÝ�A�q˜!˜QÑÔˆÝ˜�J q¨!Ñ,Ô,¨a°°AÑ6Ô6ˆˆå˜ÑÔ€Aà—’‘	”	ð 
&ð 
&‰ˆˆ1Ø�‰Eˆàð 	&Ý˜˜Q  1Ñ%Ô%ˆBˆBØ�!ŠVˆVÝ˜˜Q  1Ñ%Ô%ˆBˆBØ�!ŠVˆVÝ˜˜Q  1Ñ%Ô%ˆBˆBå˜˜Q  1Ñ%Ô%ˆBˆBàˆrˆ6€Mr@   c                 ó„   — t          | ¦  «        } t          t          | ¦  «        dz
  dd¦  «        D ]}| |          | |<   Œ| S )zô
    Evaluate efficiently the composition ``f(-x)`` in ``K[x]``.

    Examples
    ========

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

    >>> R.dup_mirror(x**3 + 2*x**2 - 4*x + 2)
    -x**3 + 2*x**2 + 4*x + 2

    r‚   rS   éþÿÿÿ)Úlistr3   rv   )r6   r8   r:   s      r>   Ú
dup_mirrorr¶   C  sJ   € õ 	ˆQ‰Œ€Aå•3�q‘6”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/   rS   ©rµ   rv   r3   )r6   rg   r8   r<   Úbr:   s         r>   Ú	dup_scalerº   Y  sb   € õ �1‰gŒg•s˜1‘v”v ‘z 1ˆ!€q€Aå�1�q‘5˜"˜bÑ!Ô!ð ð ˆØ�A�a”D‘&˜!˜A™#ˆˆˆ!‰ˆaˆaà€Hr@   c                 óÎ   — t          | ¦  «        t          | ¦  «        dz
  }} t          |dd¦  «        D ]1}t          d|¦  «        D ]}| |dz   xx         || |         z  z  cc<   ŒŒ2| S )zç
    Evaluate efficiently Taylor shift ``f(x + a)`` in ``K[x]``.

    Examples
    ========

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

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

    r/   r   rS   r¸   )r6   rg   r8   r<   r:   r=   s         r>   Ú	dup_shiftr¼   o  s}   € õ �‰7Œ7•C˜‘F”F˜Q‘J€q€Aå�1�a˜‰_Œ_ð ð ˆÝ�q˜!‘”ð 	ð 	ˆAØˆa�!‰eˆHˆHŒH˜˜!˜Aœ$™ÑˆHˆH‰HˆHð	ð €Hr@   c                 óö  ‡‡‡	— ‰st          | |d         ‰¦  «        S t          | ‰¦  «        r| S |d         |dd…         c}Š	t          ‰	¦  «        rˆˆ	ˆfd„| D ¦   «         } nt          | ¦  «        } |rxt	          | ¦  «        dz
  }t          |dd¦  «        D ]T}t          d|¦  «        D ]A}t          | |         |‰dz
  ‰¦  «        }t          | |dz            |‰dz
  ‰¦  «        | |dz   <   ŒBŒUt          | ‰¦  «        S )a°  
    Evaluate efficiently Taylor shift ``f(X + A)`` in ``K[X]``.

    Examples
    ========

    >>> from sympy import symbols, ring, ZZ
    >>> x, y = symbols('x y')
    >>> R, _, _ = ring([x, y], ZZ)

    >>> p = x**2*y + 2*x*y + 3*x + 4*y + 5

    >>> R.dmp_shift(R(p), [ZZ(1), ZZ(2)])
    x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22

    >>> p.subs({x: x + 1, y: y + 2}).expand()
    x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22
    r   r/   Nc                 ó:   •— g | ]}t          |‰‰d z
  ‰¦  «        ‘ŒS rs   )Ú	dmp_shift)rJ   r;   r8   Úa1rB   s     €€€r>   rL   zdmp_shift.<locals>.<listcomp>¢  s+   ø€ Ð3Ð3Ð3¨1�i˜˜2˜q ™s AÑ&Ô&Ð3Ð3Ð3r@   rS   )	r¼   r%   Úanyrµ   rv   r3   r   r   r   )
r6   rg   rB   r8   Úa0r<   r:   r=   ÚafjrÀ   s
     ``     @r>   r¿   r¿   †  s-  øøø€ ð& ð %Ý˜˜A˜aœD !Ñ$Ô$Ð$å�!�QÑÔð ØˆàˆqŒT�1�Q�R�R”5€F€Bˆå
ˆ2�w„wð Ø3Ð3Ð3Ð3Ð3Ð3°Ð3Ñ3Ô3ˆˆå�‰GŒGˆà	ð :Ý�‰FŒF�Q‰Jˆå�q˜!˜R‘”ð 	:ð 	:ˆAÝ˜1˜a‘[”[ð :ð :�Ý$ Q q¤T¨2¨q°©s°AÑ6Ô6�Ý" 1 Q¨¡U¤8¨S°!°A±#°qÑ9Ô9��!�a‘%‘�ð:õ �Q˜‰?Œ?Ðr@   c                 ó‚  — | sg S t          | ¦  «        dz
  }| d         g|j        gg}}t          d|¦  «        D ],}|                     t	          |d         ||¦  «        ¦  «         Œ-t          | dd…         |dd…         ¦  «        D ]8\  }}t	          |||¦  «        }t          |||¦  «        }t          |||¦  «        }Œ9|S )a  
    Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``.

    Examples
    ========

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

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

    r/   r   rS   N)rv   r­   r3   rT   r
   Úzipr   r   )	r6   r‡   Úqr8   r<   rw   ÚQr:   r;   s	            r>   Údup_transformrÈ   ±  sØ   € ð ð Øˆ	åˆA‰Œ�‰
€AØˆaŒDˆ6�Q”U�G�9€q€Aå�1�a‰[Œ[ð 'ð 'ˆØ	�Š•˜˜2œ  1Ñ%Ô%Ñ&Ô&Ð&Ð&å�A�a�b�b”E˜1˜Q˜R˜Rœ5Ñ!Ô!ð ð ‰ˆˆ1Ý�A�q˜!ÑÔˆÝ˜1˜a Ñ#Ô#ˆÝ�A�q˜!ÑÔˆˆà€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)rv   r   ri   r   r
   r   )r6   r9   r8   rw   r;   s        r>   Údup_composerÊ   Ð  s’   € õ ˆ1�v„v�‚{€{Ý�( 1¥f¨Q°¡l¤l°AÑ6Ô6Ð7Ñ8Ô8Ð8àð Øˆ	à	
ˆ1Œˆ€AàˆqˆrˆrŒUð %ð %ˆÝ�A�q˜!ÑÔˆÝ˜˜A˜q !Ñ$Ô$ˆˆà€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   rw   r;   s         r>   Údmp_composerÌ   í  s†   € ð ð $Ý˜1˜a Ñ#Ô#Ð#å�!�QÑÔð Øˆà	
ˆ1Œˆ€AàˆqˆrˆrŒUð (ð (ˆÝ�A�q˜!˜QÑÔˆÝ˜˜A˜q ! QÑ'Ô'ˆˆà€Hr@   c                 ó¸  — t          | ¦  «        dz
  }t          | |¦  «        }t          | ¦  «        } ||j        i}||z  }t	          d|¦  «        D ]{}|j        }t	          d|¦  «        D ]?}	||	z   |z
  | vrŒ||	z
  |vrŒ| ||	z   |z
           |||	z
           }}
||||	z  z
  |
z  |z  z  }Œ@|                     |||z  |z  ¦  «        |||z
  <   Œ|t          ||¦  «        S )ú+Helper function for :func:`_dup_decompose`.r/   r   )rv   r   r&   r­   r3   r0   Úquor'   )r6   Úsr8   r<   r“   r9   Úrr:   rV   r=   r¥   r¦   s               r>   Ú_dup_right_decomposerÒ   
  s  € åˆA‰Œ�‰
€AÝ	��1‰Œ€Bå˜ÑÔ€AØ
ˆQŒUˆ€Aà	ˆQ‰€Aå�1�a‰[Œ[ð (ð (ˆØ”ˆå�q˜!‘”ð 	%ð 	%ˆAØ�q‘5˜1‘9 �>�>Øà�q‘5˜A�:�:Øà�q˜1‘u˜q‘y”\ 1 Q¨¡U¤8�ˆBØ�a˜!˜A™#‘g˜r‘\ "‘_Ñ$ˆEˆEà—5’5˜  !¡ B¡Ñ'Ô'ˆˆ!ˆa‰%‰ˆå˜Q Ñ"Ô"Ð"r@   c                 ó¸   — i d}}| rEt          | ||¦  «        \  }}t          |¦  «        dk    rdS t          ||¦  «        ||<   ||dz   }} | °Et          ||¦  «        S )rÎ   r   Nr/   )r   r   r   r'   )r6   rw   r8   r9   r:   rÆ   rÑ   s          r>   Ú_dup_left_decomposerÔ   &  sx   € àˆq€q€Aà
ð Ý�q˜!˜QÑÔ‰ˆˆ1å�a‰=Œ=˜1ÒÐØ�4å˜!˜Q‘<”<ˆAˆa‰DØ�a˜!‘eˆqˆAð ð õ ˜Q Ñ"Ô"Ð"r@   c                 ó¼   — t          | ¦  «        dz
  }t          d|¦  «        D ]8}||z  dk    rŒt          | ||¦  «        }|�t          | ||¦  «        }|�||fc S Œ9dS )z*Helper function for :func:`dup_decompose`.r/   r‚   r   N)rv   r3   rÒ   rÔ   )r6   r8   ÚdfrÐ   rw   r9   s         r>   Ú_dup_decomposer×   6  sw   € å	ˆQ‰Œ�!‰€Bå�1�b‰\Œ\ð 
ð 
ˆØ�‰6�QŠ;ˆ;Øå   A qÑ)Ô)ˆàˆ=Ý# A q¨!Ñ,Ô,ˆAàˆ}Ø˜!�t���øàˆ4r@   c                 óT   — g }	 t          | |¦  «        }|�|\  } }|g|z   }nnŒ | g|z   S )ae  
    Computes functional decomposition of ``f`` in ``K[x]``.

    Given a univariate polynomial ``f`` with coefficients in a field of
    characteristic zero, returns list ``[f_1, f_2, ..., f_n]``, where::

              f = f_1 o f_2 o ... f_n = f_1(f_2(... f_n))

    and ``f_2, ..., f_n`` are monic and homogeneous polynomials of at
    least second degree.

    Unlike factorization, complete functional decompositions of
    polynomials are not unique, consider examples:

    1. ``f o g = f(x + b) o (g - b)``
    2. ``x**n o x**m = x**m o x**n``
    3. ``T_n o T_m = T_m o T_n``

    where ``T_n`` and ``T_m`` are Chebyshev polynomials.

    Examples
    ========

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

    >>> R.dup_decompose(x**4 - 2*x**3 + x**2)
    [x**2, x**2 - x]

    References
    ==========

    .. [1] [Kozen89]_

    )r×   )r6   r8   ÚFrh   rw   s        r>   Údup_decomposerÚ   I  sO   € ðH 	€AðÝ  1Ñ%Ô%ˆàÐØ‰DˆAˆqØ��a‘ˆ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á   {  sY   € ð, 	Ôð Q˜AÔ.ð QÝ'¨¨1¨aÑ0Ô0Ð0Ø	
Œð QÝ" 1 a¨Ñ+Ô+Ð+åÐOÑPÔPÐPr@   c                 óê   — t          | |¦  «        i }} |                      ¦   «         D ]'\  }}|j        |j        }}|r||d|z   <   |r||d|z   <   Œ(t	          ||dz   |j        ¦  «        }||dz   |j        fS )ú+Helper function for :func:`dmp_alg_inject`.)r   rs   r/   )r   r®   ÚxÚyr   Údom)	r6   rB   r8   rw   Úf_monomr9   rä   rå   rÙ   s	            r>   rÞ   rÞ   ™  s“   € å�q˜!ÑÔ˜b€q€Aà—g’g‘i”ið "ð "‰
ˆ�ØŒs�A”Cˆ1ˆØð 	"Ø !ˆAˆd�W‰nÑØð 	"Ø !ˆAˆd�W‰nÑøå�a˜˜Q™ ¤Ñ&Ô&€Aàˆa�!‰e�Q”Uˆ?Ðr@   c                 ó  — t          | |¦  «        i }} |                      ¦   «         D ]9\  }}|                     ¦   «                              ¦   «         D ]\  }}||||z   <   ŒŒ:t          ||dz   |j        ¦  «        }||dz   |j        fS )rã   r/   )r   r®   Úto_dictr   ræ   )	r6   rB   r8   rw   rç   r9   Úg_monomr;   rÙ   s	            r>   rà   rà   ©  s™   € å�q˜!ÑÔ˜b€q€Aà—g’g‘i”ið %ð %‰
ˆ�ØŸ)š)™+œ+×+Ò+Ñ-Ô-ð 	%ð 	%‰JˆG�QØ#$ˆAˆg˜ÑÑ Ð ð	%õ 	�a˜˜Q™ ¤Ñ&Ô&€Aàˆa�!‰e�Q”Uˆ?Ðr@   c           
      óæ   — ddl m} t          | ||¦  «        \  }}}|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ó   ¶  sy   € ð( +Ð*Ð*Ð*Ð*Ð*å˜a  AÑ&Ô&�H€A€qˆ"à
Œ%�-Š-‰/Œ/€CÝ
�c�4¥ a¨¨Q©¡¤Ñ0Ô0°!°RÑ
8Ô
8€Càˆ=˜˜C  BÑ'Ô'Ð'r@   c                 ó¾  ‡— ˆfd„}‰j         s‰j        s‰j        r‰j        }n”‰j        r‰j        j        r|}n~‰j        s‰j        r^t          ‰j
        ¦  «        dk    rF‰j        j         s‰j        j        s‰j        r'‰j
        d         j        r‰j
        d         j        r|}nt          d‰z  ¦  «        ‚‰j        d}}| D ]} |||z  ¦  «        r|dz  }|r|}Œ|S )zâ
    Compute the number of sign variations of ``f`` in ``K[x]``.

    Examples
    ========

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

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

    c                 óX   •— | sdS t          ‰                     | ¦  «        dk     ¦  «        S )NFr   )ÚboolÚto_sympy)rg   r8   s    €r>   Úis_negative_sympyz.dup_sign_variations.<locals>.is_negative_sympyâ  s/   ø€ Øð 		+à�5õ ˜Ÿ
š
 1™œ¨Ò)Ñ*Ô*Ð*r@   r/   r   z-sign variation counting not supported over %s)rˆ   r¬   Úis_RRÚis_negativeÚis_AlgebraicFieldÚextÚis_comparableÚis_PolynomialRingÚis_FractionFieldrv   Úsymbolsræ   Úis_transcendentalr+   r0   )r6   r8   rø   rú   ÚprevrW   rV   s    `     r>   Údup_sign_variationsr  Ô  sB  ø€ ð
+ð 
+ð 
+ð 
+ð 
+ð  	„wð O�!”'ð O˜QœWð OØ”mˆˆØ	
Ô	ð 	O ¤Ô!4ð 	OØ'ˆˆØÔð O !Ô"4ð O½#¸a¼i¹.¼.ÈAÒ:MÐ:MØŒ5Œ;ð ;NØœ%œ+ð ;NØ)*Ô)<ð ;Nà
Œ)�AŒ,Ô
(ð ;Nà-.¬Y°q¬\Ô-Gð ;Nð
 (ˆˆåÐIÈAÑMÑNÔNÐNàŒf�aˆ!€Dàð ð ˆØˆ;�u˜T‘zÑ"Ô"ð 	Ø�‰FˆAàð 	ØˆDøà€Hr@   NFc                 ó`  ‡‡‡— ‰€‰j         r‰                     ¦   «         Šn‰Š‰j        Š| D ]+}‰                     ‰‰                     |¦  «        ¦  «        ŠŒ,‰                     ‰¦  «        r|s‰| fS ‰t          | ‰‰¦  «        fS ˆˆˆfd„| D ¦   «         } |s‰t          | ‰‰¦  «        fS ‰| fS )a@  
    Clear denominators, i.e. transform ``K_0`` to ``K_1``.

    Examples
    ========

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

    >>> f = QQ(1,2)*x + QQ(1,3)

    >>> R.dup_clear_denoms(f, convert=False)
    (6, 3*x + 2)
    >>> R.dup_clear_denoms(f, convert=True)
    (6, 3*x + 2)

    Nc           	      óŽ   •— g | ]A}‰                      |¦  «        ‰                     ‰‰                     |¦  «        ¦  «        z  ‘ŒBS rG   )ÚnumerrÏ   Údenom)rJ   r;   ÚK0ÚK1Úcommons     €€€r>   rL   z$dup_clear_denoms.<locals>.<listcomp>0  s@   ø€ Ð<Ð<Ð<°Qˆ�Š�!‰Œ�R—V’V˜F B§H¢H¨Q¡K¤KÑ0Ô0Ñ	0Ð<Ð<Ð<r@   )Úhas_assoc_RingÚget_ringr­   Úlcmr  r’   r   )r6   r  r	  rf   r;   r
  s    ``  @r>   Údup_clear_denomsr    sç   øøø€ ð$ 
€zØÔð 	Ø—’‘”ˆBˆBàˆBàŒV€Fàð -ð -ˆØ—’˜ §¢¨¡¤Ñ,Ô,ˆˆà	‡y‚y�ÑÔð 2Øð 	2Ø˜1�9Ðà�; q¨"¨bÑ1Ô1Ð1Ð1ð 	=Ð<Ð<Ð<Ð<Ð<¸!Ð<Ñ<Ô<€Aàð Ø•{ 1 b¨"Ñ-Ô-Ð-Ð-à�qˆyÐr@   c           
      óÖ   — |j         }|s/| D ]+}|                     ||                     |¦  «        ¦  «        }Œ,n0|dz
  }| D ](}|                     |t          ||||¦  «        ¦  «        }Œ)|S )z.Recursive helper for :func:`dmp_clear_denoms`.r/   )r­   r  r  Ú_rec_clear_denoms)r9   rC   r  r	  r
  r;   rK   s          r>   r  r  8  sŠ   € àŒV€Fàð EØð 	1ð 	1ˆAØ—V’V˜F B§H¢H¨Q¡K¤KÑ0Ô0ˆFˆFð	1ð �‰Eˆàð 	Eð 	EˆAØ—V’V˜FÕ$5°a¸¸BÀÑ$CÔ$CÑDÔDˆFˆFà€Mr@   c                 ó  — |st          | |||¬¦  «        S |€|j        r|                     ¦   «         }n|}t          | |||¦  «        }|                     |¦  «        st          | |||¦  «        } |s|| fS |t          | |||¦  «        fS )aV  
    Clear denominators, i.e. transform ``K_0`` to ``K_1``.

    Examples
    ========

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

    >>> f = QQ(1,2)*x + QQ(1,3)*y + 1

    >>> R.dmp_clear_denoms(f, convert=False)
    (6, 3*x + 2*y + 6)
    >>> R.dmp_clear_denoms(f, convert=True)
    (6, 3*x + 2*y + 6)

    )rf   )r  r  r  r  r’   r   r   )r6   rB   r  r	  rf   r
  s         r>   Údmp_clear_denomsr  H  s¬   € ð$ ð <Ý  2 r°7Ð;Ñ;Ô;Ð;à	€zØÔð 	Ø—’‘”ˆBˆBàˆBå˜q ! R¨Ñ,Ô,€Fà�9Š9�VÑÔð -Ý˜1˜f a¨Ñ,Ô,ˆàð 1Ø�qˆyÐà•{ 1 a¨¨RÑ0Ô0Ð0Ð0r@   c                 óâ  — |                      t          | |¦  «        ¦  «        g}|j        |j        |j        g}t	          t          t          |¦  «        ¦  «        ¦  «        }t          d|dz   ¦  «        D ]y}t          | |d¦  «        |¦  «        }t          | t          ||¦  «        |¦  «        }t          t          |||¦  «        ||¦  «        }t          |t          |¦  «        |¦  «        }Œz|S )a÷  
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

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

    Examples
    ========

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

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

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

    r/   r‚   )Úrevertr!   r­   r0   r„   Ú_ceilÚ_log2r3   r   r
   r   r   r   r   r   )	r6   r<   r8   r9   rw   ÚNr:   rg   r¹   s	            r>   Ú
dup_revertr  n  sÓ   € ð( 
�Š•&˜˜A‘,”,Ñ	Ô	Ð €AØ	
Œ�”˜œÐ€Aå�E•%˜‘(”(‰OŒOÑÔ€Aå�1�a˜!‘e‰_Œ_ð ,ð ,ˆÝ˜1˜a˜a ™dœd AÑ&Ô&ˆÝ�A•w˜q !‘}”} aÑ(Ô(ˆÝ•G˜A˜q !Ñ$Ô$ a¨Ñ+Ô+ˆÝ�q�* Q™-œ-¨Ñ+Ô+ˆˆà€Hr@   c                 óH   — |st          | ||¦  «        S t          | |¦  «        ‚)z©
    Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

    Examples
    ========

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

    )r  r*   )r6   r9   rB   r8   s       r>   Ú
dmp_revertr  �  s.   € ð ð 0Ý˜!˜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   rH   rQ   rX   rZ   r]   rc   ri   rk   rn   rp   rt   rz   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  rG   r@   r>   ú<module>r      s  ðØ NÐ Nðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð
 .Ð -Ð -Ð -Ð -Ð -Ð -Ð -ðð ð ð@ ð  ð  ðFLð Lð Lð/ð /ð /ð,(ð (ð (ðV,ð ,ð ,ð^Gð Gð Gð*ð *ð *ð0ð ð ð4ð ð ð:Gð Gð Gð*ð *ð *ð0
1ð 
1ð 
1ð(ð (ð (ð@Lð Lð Lð/ð /ð /ð4ð ð ðD@ð @ð @ð(Eð Eð Eð0*ð *ð *ð:!-ð !-ð !-ðH'ð 'ð 'ðT*ð *ð *ðZ0ð 0ð 0ðB!3ð !3ð !3ðHð ð ð4ð ð ð41ð 1ð 1ðhð ð ð,ð ð ð,ð ð ð.(ð (ð (ðVð ð ð>ð ð ð:ð ð ð:#ð #ð #ð8#ð #ð #ð ð ð ð&/ð /ð /ðdQð Qð Qð<ð ð ð 
ð 
ð 
ð(ð (ð (ð<4ð 4ð 4ðn*ð *ð *ð *ðZð ð ð #1ð #1ð #1ð #1ðLð ð ðD0ð 0ð 0ð 0ð 0r@   