
    Цij                        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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)  SSK*J+r+J,r,  SSK-J.r.  SSK/J0r1J2r3  S 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[S/ r\S6S1 jr]S2 r^S6S3 jr_S4 r`S5 rag0)7zHAdvanced tools for dense recursive polynomials in ``K[x]`` or ``K[X]``.     )dup_add_termdmp_add_term
dup_lshiftdup_adddmp_adddup_subdmp_subdup_muldmp_muldup_sqrdup_divdup_remdmp_rem
dmp_expanddup_mul_grounddmp_mul_grounddup_quo_grounddmp_quo_grounddup_exquo_grounddmp_exquo_ground)	dup_strip	dmp_stripdup_convertdmp_convert
dup_degree
dmp_degreedmp_to_dictdmp_from_dictdup_LCdmp_LCdmp_ground_LCdup_TCdmp_TCdmp_zero
dmp_ground
dmp_zero_pdup_to_raw_dictdup_from_raw_dict	dmp_zeros)MultivariatePolynomialErrorDomainError)
variations)ceillog2c           
         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           U/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/polys/densetools.pydup_integrater@   '   s      	AvQ	

A(1+&Eq!AQNA  	
AGGAq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	XU	-   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   r0   )r@   r&   r)   r2   r3   r4   r5   r   )
r7   r8   ur9   r:   vr;   r<   r=   r>   s
             r?   dmp_integraterE   G   s      Q1%%AvA!!QAq!1q5q(1+&Eq!AQNA  	
N1adA12 ' HrA   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`.r0   )rE   r   _rec_integrate_inr:   r8   rD   r;   r>   r9   wr<   s           r?   rG   rG   j   sL    vQ1((q5!a%qAGAq(qQ: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)
IndexErrorrG   r7   r8   r>   rC   r9   s        r?   dmp_integrate_inrN   t   s3      	1uCqfLMMQ1a..rA   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   r0   N)r   appendr4   r   )r7   r8   r9   r=   derivcoeffkr;   s           r?   dup_diffrU      s      	Av1Au	EAvsVELL1e$FA  sVEA1q5!%, - LL1e$FA  UrA   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   r0   NrP   )rU   r   r$   rQ   r   r4   r   )
r7   r8   rC   r9   r=   rR   rD   rS   rT   r;   s
             r?   dmp_diffrW      s    $ a  Av1Au{1q51AvsVELLqtQ:;FA  sVEA1q5!%, - LLqtQ:;FA  UrA   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`.r0   )rW   r   _rec_diff_inrH   s           r?   rY   rY      K    va##q5!a%qqBq!|A!5qBAFFBrJ   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 )rL   rY   rM   s        r?   dmp_diff_inr^      0    $ 	1uAqABBaA))rA   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"   r1   )r7   ar9   resultr<   s        r?   dup_evalrd     sB     yy&&VVF  MrA   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

r0   N)rd   r#   r    r   r   )r7   rb   rC   r9   rc   rD   rS   s          r?   dmp_evalrf      s_     a  a|qa!eA1210-  MrA   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`.r0   )rf   r   _rec_eval_in)r:   rb   rD   r;   r>   r9   r<   s          r?   rh   rh   =  rZ   rJ   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]   )rL   rh   )r7   rb   r>   rC   r9   s        r?   dmp_eval_inrj   G  r_   rA   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`.rP   r0   )rd   _rec_eval_taillen)r:   r;   ArC   r9   r<   hs          r?   rl   rl   _  sp    vR5!$$9:<AnQAqQ/<3q6zA~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   r0   )r&   r$   rm   rl   r   )r7   rn   rC   r9   es        r?   dmp_eval_tailrr   l  sa    $ !CF
##q!Q1%ACFQJAJ''rA   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`.r0   )rf   rW   r   _rec_diff_eval)r:   r8   rb   rD   r;   r>   r9   r<   s           r?   rt   rt     sV    vq,aA66q5!a%qAGAq~aA!: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   )rL   rf   rW   rt   )r7   r8   rb   r>   rC   r9   s         r?   dmp_diff_eval_inrw     sE    $ 	uQ1EFFq,aA66!a..rA   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_ZZrQ   is_FiniteFieldintr   )r7   pr9   r:   r<   pis         r?   	dup_truncr     s     	wwAA6z  
		V&')aaAna) Q!eQ 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

r0   )r   r   )r7   r}   rC   r9   r<   s        r?   	dmp_truncr     s0    " ;1wqQUA.;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

r0   )r   r   dmp_ground_trunc)r7   r}   rC   r9   rD   r<   s         r?   r   r     sD      q!!	AAQ@Q'a3Q@!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   )r7   r9   lcs      r?   	dup_monicr     s4    $ 	Bxx||q))rA   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   )r7   rC   r9   r   s       r?   dmp_ground_monicr     sL    , !	qQ	Bxx||q,,rA   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   r1   gcdr   )r7   r9   r   contr<   s        r?   dup_contentr   ?  st    , 'vv66DwA55>D  K A55>Dxx~~K  KrA   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   r0   )r   r   r   r&   r1   r   dmp_ground_contentr   )r7   rC   r9   r   r   rD   r<   s          r?   r   r   i  s    , '1  !vvffa!e!wA551!:;D  K A551!:;Dxx~~K  KrA   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)

)r1   r   r   r   )r7   r9   r   s      r?   dup_primitiver     sE    , vvqyqDxx~~w^AQ///rA   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&   r1   r   r   r   )r7   rC   r9   r   s       r?   dmp_ground_primitiver     s]    , Q""!vvqyaA&Dxx~~w^AQ222rA   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   )r7   r:   r9   fcgcr   s         r?   dup_extractr     sT     
Q	B	Q	B
%%-C88C==11%11%19rA   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   )r7   r:   rC   r9   r   r   r   s          r?   dmp_ground_extractr     sX     
A!	$B	A!	$B
%%-C88C==11(11(19rA   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  pU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 %sr0   r   ry   N   )rz   is_QQr+   r$   oner1   r%   r   r   r'   itemsr   r	   )
r7   r9   f1f2r:   ro   r<   HrT   r8   s
             r?   dup_real_imagr     s"   & 77177WZ[[\\	!B	!Bv55!&&/	aeeWbM*A1Q4AqrUA!QJq!,aA6  	A	E1%B!V1%B!V1%B1%B  6MrA   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

ry   rP   )listr4   rm   )r7   r9   r;   s      r?   
dup_mirrorr   C  s:     	QA3q6A:r2&u ' HrA   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

r0   rP   r   rm   r4   )r7   rb   r9   r=   br;   s         r?   	dup_scaler   Y  sN     1gs1vz1!A1q5"b!aD&!#a " HrA   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

r0   r   rP   r   )r7   rb   r9   r=   r;   r>   s         r?   	dup_shiftr   o  sV     7CFQJq1a_q!A!eHA$H   HrA   c           	      t   U(       d  [        XS   U5      $ [        X5      (       a  U $ US   USS pTU  Vs/ s H  n[        XeUS-
  U5      PM     n n[        U 5      S-
  n[	        USS5       HB  n[	        SU5       H/  n	[        X	   XBS-
  U5      n
[        X	S-      XS-
  U5      X	S-   '   M1     MD     U $ 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   r0   NrP   )r   r&   	dmp_shiftrm   r4   r   r   )r7   rb   rC   r9   a0a1r<   r=   r;   r>   afjs              r?   r   r     s    & aD!$$!qT1QR5,-/Aq)A1Q3
"AA/A
A1a_q!A rQ32CqQxc15A!eH  
 H 	0s   B5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

r0   r   rP   N)rm   r   r4   rQ   r
   zipr   r   )	r7   r}   qr9   r=   ro   Qr;   r<   s	            r?   dup_transformr     s     	A
AaD6QUUG9q1a[	2%&  AabE1QR5!A!1#A! "
 HrA   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

r0   r   N)rm   r   rd   r   r
   r   )r7   r:   r9   ro   r<   s        r?   dup_composer     sn     1v{(1fQlA6788		
1AqrUA!q!$  HrA   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   r0   N)r   r&   r   r   )r7   r:   rC   r9   ro   r<   s         r?   dmp_composer     s`     1##!	
1AqrUA!q!'  HrA   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	-
     pXXi-  -
  U
-  U-  -  nM;     UR                  XU-  U-  5      XQU-
  '   Mv     [        XR5      $ )+Helper function for :func:`_dup_decompose`.r0   r   )rm   r   r'   r   r4   r1   quor(   )r7   sr9   r=   r   r:   rr;   rS   r>   r   r   s               r?   _dup_right_decomposer     s    A
A	BA
UUA	A1a[q!A519>5A:1uqy\1U8!#gr\"_$E  55!B'a%  Q""rA   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   Nr0   )r   r   r   r(   )r7   ro   r9   r:   r;   r   r   s          r?   _dup_left_decomposer   !  sQ    qq
qQa=1!<AD!eq ! Q""rA   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`.r0   ry   r   N)rm   r4   r   r   )r7   r9   dfr   ro   r:   s         r?   _dup_decomposer   1  sY    	Q!B1b\6Q; q)=#A!,A}t  rA   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   )r7   r9   Frc   ro   s        r?   dup_decomposer   D  sD    H 	A
%DAaA  37NrA   c                 @   UR                   (       a  UR                  5       n[        XX#5      n UnUR                  (       d  [	        S5      e[        X5      / / penUR                  5        H)  u  pxUR                  (       a  M  UR                  U5        M+     [        SS/[        U5      SS9n	U	 HL  n
[        U5      n[        X5       H  u  pUS:X  d  M  X   * X'   M     UR                  [        XU5      5        MN     [        [        XaU5      XUR                  5      $ )a2  
Convert algebraic coefficients to integers in ``K[X]``.

Examples
========

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

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

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

>>> R.dmp_lift(f)
x**8 + 2*x**6 + 9*x**4 - 8*x**2 + 16

z3computation can be done only in an algebraic domainrP   r0   T)
repetition)is_GaussianFieldas_AlgebraicFieldr   is_Algebraicr+   r   r   	is_groundrQ   r,   rm   dictr   r   r   dom)r7   rC   r9   K1r   monomspolysmonomrS   permspermGsigns                r?   dmp_liftr   v  s    & 	  "a$>>AC 	C #1("buA	MM%  " AwF=EGt,KDrzH9 - 	]1+,  z%A.aee<<rA   c                     UR                   Sp2U  H+  nUR                  XB-  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

r   r0   )r1   is_negative)r7   r9   prevrT   rS   s        r?   dup_sign_variationsr     sD     ffa!==$$FA5D  HrA   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   )r7   K0r   ra   commonr<   s         r?   dup_clear_denomsr     s    $ 
zBBVVF,  
yy9;qb111 ;<<!Q!RVVFHHQK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`.r0   )r   r   r   _rec_clear_denoms)r:   rD   r   r   r   r<   rI   s          r?   r   r     si    VVFAVVFHHQK0F  M EAVVF$5aB$CDF  MrA   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)

)ra   )r   r   r   r   r   r   r   )r7   rC   r   r   ra   r   s         r?   dmp_clear_denomsr     sv    $ r;;	zBBqR,F99V1a,y{1000rA   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

r0   ry   )revertr"   r   r1   r|   _ceil_log2r4   r   r
   r   r   r   r   r   )	r7   r=   r9   r:   ro   Nr;   rb   r   s	            r?   
dup_revertr   #  s    ( 
&,	 A	
AE%(OA1a!e_1adA&Awq}a(GA!$a+q*Q-+	  HrA   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*   )r7   r:   rC   r9   s       r?   
dmp_revertr   E  s     !"")!//rA   )NF)b__doc__sympy.polys.densearithr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   sympy.polys.densebasicr   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   sympy.polys.polyerrorsr*   r+   sympy.utilitiesr,   mathr-   r   r.   r   r@   rE   rG   rN   rU   rW   rY   r^   rd   rf   rh   rj   rl   rr   rt   rw   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    rA   r?   <module>r      sO   N           ' -@ FL/,(V,^G*04:G*0
1(@L/4D@(E0*:!-H'T*Z0B!3H441h,,.#L>::#8# &/d-=`4*Z #1LD0rA   