
    \h2t                        S r SSKJrJrJrJrJrJrJrJ	r	J
r
JrJrJrJrJrJrJrJrJrJr  SSKJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)  SSK*J+r+J,r,  SSK-J.r/J0r1  S r2S r3S r4S	 r5S
 r6S r7S r8S r9S r:S r;S r<S r=S r>S r?S r@S rAS rBS rCS rDS rES rFS rGS rHS rIS rJS rKS  rLS! rMS" rNS# rOS$ rPS% rQS& rRS' rSS( rTS) rUS* rVS+ rWS, rXS- rYS. rZS/ r[S0 r\S1 r]S8S3 jr^S4 r_S8S5 jr`S6 raS7 rbg2)9zHAdvanced tools for dense recursive polynomials in ``K[x]`` or ``K[X]``.     )dup_add_termdmp_add_term
dup_lshiftdup_adddmp_adddup_subdmp_subdup_muldmp_muldup_sqrdup_divdup_remdmp_remdup_mul_grounddmp_mul_grounddup_quo_grounddmp_quo_grounddup_exquo_grounddmp_exquo_ground)	dup_strip	dmp_stripdup_convertdmp_convert
dup_degree
dmp_degreedmp_to_dictdmp_from_dictdup_LCdmp_LCdmp_ground_LCdup_TCdmp_TCdmp_zero
dmp_ground
dmp_zero_pdup_to_raw_dictdup_from_raw_dict	dmp_zerosdmp_include)MultivariatePolynomialErrorDomainError)ceillog2c           
         US::  d  U (       d  U $ UR                   /U-  n[        [        U 5      5       HN  u  pEUS-   n[        SU5       H  nXdU-   S-   -  nM     UR	                  SUR                  XR" U5      5      5        MP     U$ )z
Computes the indefinite integral of ``f`` in ``K[x]``.

Examples
========

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

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

r      )zero	enumeratereversedrangeinsertexquo)fmKgicnjs           N/var/www/auris/envauris/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   r/   )r?   r%   r(   r1   r2   r3   r4   r   )
r6   r7   ur8   r9   vr:   r;   r<   r=   s
             r>   dmp_integraterD   G   s      Q1%%AvA!!QAq!1q5q(1+&Eq!AQNA  	
N1adA12 ' Hr@   c                     X4:X  a  [        XX%5      $ US-
  US-   p6[        U  Vs/ s H  n[        XqXcXE5      PM     snU5      $ s  snf )z.Recursive helper for :func:`dmp_integrate_in`.r/   )rD   r   _rec_integrate_inr9   r7   rC   r:   r=   r8   wr;   s           r>   rF   rF   j   sL    v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)
IndexErrorrF   r6   r7   r=   rB   r8   s        r>   dmp_integrate_inrM   t   s3      	1uCqfLMMQ1a..r@   c                 L   US::  a  U $ [        U 5      nX1:  a  / $ / nUS:X  a-  U SU*   H"  nUR                  U" U5      U-  5        US-  nM$     OKU SU*   HA  nUn[        US-
  X1-
  S5       H  nXg-  nM	     UR                  U" U5      U-  5        US-  nMC     [        U5      $ )z
``m``-th order derivative of a polynomial in ``K[x]``.

Examples
========

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

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

r   r/   N)r   appendr3   r   )r6   r7   r8   r<   derivcoeffkr:   s           r>   dup_diffrT      s      	Av1Au	EAvsVELL1e$FA  sVEA1q5!%, - LL1e$FA  Ur@   c           	         U(       d  [        XU5      $ US::  a  U $ [        X5      nXA:  a  [        U5      $ / US-
  peUS:X  a4  U SU*   H)  nUR                  [	        Xs" U5      Xc5      5        US-  nM+     ORU SU*   HH  nUn[        US-
  XA-
  S5       H  n	X-  nM	     UR                  [	        Xs" U5      Xc5      5        US-  nMJ     [        XR5      $ )a  
``m``-th order derivative in ``x_0`` of a polynomial in ``K[X]``.

Examples
========

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

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

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

r   r/   NrO   )rT   r   r#   rP   r   r3   r   )
r6   r7   rB   r8   r<   rQ   rC   rR   rS   r:   s
             r>   dmp_diffrV      s    $ a  Av1Au{1q51AvsVELLqtQ:;FA  sVEA1q5!%, - LLqtQ:;FA  Ur@   c                     X4:X  a  [        XX%5      $ US-
  US-   p6[        U  Vs/ s H  n[        XqXcXE5      PM     snU5      $ s  snf )z)Recursive helper for :func:`dmp_diff_in`.r/   )rV   r   _rec_diff_inrG   s           r>   rX   rX      K    va##q5!a%qqBq!|A!5qBAFFBrI   c                 Z    US:  d  X#:  a  [        SU< SU< 35      e[        XUSX$5      $ )a'  
``m``-th order derivative in ``x_j`` of a polynomial in ``K[X]``.

Examples
========

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

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

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

r   
0 <= j <=  expected, got )rK   rX   rL   s        r>   dmp_diff_inr]      0    $ 	1uAqABBaA))r@   c                     U(       d  UR                  [        X5      5      $ UR                  nU  H  nX1-  nX4-  nM     U$ )z
Evaluate a polynomial at ``x = a`` in ``K[x]`` using Horner scheme.

Examples
========

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

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

)convertr!   r0   )r6   ar8   resultr;   s        r>   dup_evalrc     sB     yy&&VVF  Mr@   c                     U(       d  [        XU5      $ U(       d  [        X5      $ [        X5      US-
  pTU SS  H  n[        XAXS5      n[	        XFXS5      nM     U$ )z
Evaluate a polynomial at ``x_0 = a`` in ``K[X]`` using the Horner scheme.

Examples
========

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

>>> R.dmp_eval(2*x*y + 3*x + y + 2, 2)
5*y + 8

r/   N)rc   r"   r   r   r   )r6   ra   rB   r8   rb   rC   rR   s          r>   dmp_evalre      s_     a  a|qa!eA1210-  Mr@   c                     X4:X  a  [        XX%5      $ US-
  US-   p2[        U  Vs/ s H  n[        XaX#XE5      PM     snU5      $ s  snf )z)Recursive helper for :func:`dmp_eval_in`.r/   )re   r   _rec_eval_in)r9   ra   rC   r:   r=   r8   r;   s          r>   rg   rg   =  rY   rI   c                 Z    US:  d  X#:  a  [        SU< SU< 35      e[        XUSX$5      $ )a  
Evaluate a polynomial at ``x_j = a`` in ``K[X]`` using the Horner scheme.

Examples
========

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

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

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

r   r[   r\   )rK   rg   )r6   ra   r=   rB   r8   s        r>   dmp_eval_inri   G  r^   r@   c           
          X:X  a  [        XS   U5      $ U  Vs/ s H  n[        XQS-   X#U5      PM     nnX[        U5      -
  S-   :  a  U$ [        XbU* U-   S-
     U5      $ s  snf )z+Recursive helper for :func:`dmp_eval_tail`.rO   r/   )rc   _rec_eval_taillen)r9   r:   ArB   r8   r;   hs          r>   rk   rk   _  sp    v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   r/   )r%   r#   rl   rk   r   )r6   rm   rB   r8   es        r>   dmp_eval_tailrq   l  sa    $ !CF
##q!Q1%ACFQJAJ''r@   c                     XE:X  a  [        [        XX65      X#U5      $ US-
  US-   pC[        U  Vs/ s H  n[        XqX#XEU5      PM     snU5      $ s  snf )z+Recursive helper for :func:`dmp_diff_eval`.r/   )re   rV   r   _rec_diff_eval)r9   r7   ra   rC   r:   r=   r8   r;   s           r>   rs   rs     sV    vq,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   )rK   re   rV   rs   )r6   r7   ra   r=   rB   r8   s         r>   dmp_diff_eval_inrv     sE    $ 	uQ1EFFq,aA66!a..r@   c                 r   UR                   (       a>  / nU  H5  nXA-  nXAS-  :  a  UR                  XA-
  5        M$  UR                  U5        M7     OTUR                  (       a/  [        U5      nU  Vs/ s H  oB" [        U5      U-  5      PM     nnOU  Vs/ s H  oDU-  PM	     nn[	        U5      $ s  snf s  snf )z
Reduce a ``K[x]`` polynomial modulo a constant ``p`` in ``K``.

Examples
========

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

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

   )is_ZZrP   is_FiniteFieldintr   )r6   pr8   r9   r;   pis         r>   	dup_truncr~     s     	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

r/   )r   r   )r6   r|   rB   r8   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

r/   )r~   r   dmp_ground_trunc)r6   r|   rB   r8   rC   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   )r6   r8   lcs      r>   	dup_monicr     s4    $ 	Bxx||q))r@   c                     U(       d  [        X5      $ [        X5      (       a  U $ [        XU5      nUR                  U5      (       a  U $ [	        XX5      $ )a  
Divide all coefficients by ``LC(f)`` in ``K[X]``.

Examples
========

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

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

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

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

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

)r   r%   r    r   r   )r6   rB   r8   r   s       r>   dmp_ground_monicr     sL    , !	qQ	Bxx||q,,r@   c                     SSK Jn  U (       d  UR                  $ UR                  nX:X  a  U  H  nUR                  X45      nM     U$ U  H-  nUR                  X45      nUR	                  U5      (       d  M,    U$    U$ )a  
Compute the GCD of coefficients of ``f`` in ``K[x]``.

Examples
========

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

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

>>> R.dup_content(f)
2

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

>>> R.dup_content(f)
2

r   QQ)sympy.polys.domainsr   r0   gcdr   )r6   r8   r   contr;   s        r>   dup_contentr   ?  st    , 'vv66DwA55>D  K A55>Dxx~~K  Kr@   c           	      b   SSK Jn  U(       d  [        X5      $ [        X5      (       a  UR                  $ UR                  US-
  pTX#:X  a'  U  H  nUR                  U[        XeU5      5      nM!     U$ U  H8  nUR                  U[        XeU5      5      nUR                  U5      (       d  M7    U$    U$ )a-  
Compute the GCD of coefficients of ``f`` in ``K[X]``.

Examples
========

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

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

>>> R.dmp_ground_content(f)
2

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

>>> R.dmp_ground_content(f)
2

r   r   r/   )r   r   r   r%   r0   r   dmp_ground_contentr   )r6   rB   r8   r   r   rC   r;   s          r>   r   r   i  s    , '1  !vvffa!e!wA551!:;D  K A551!:;Dxx~~K  Kr@   c                     U (       d  UR                   U 4$ [        X5      nUR                  U5      (       a  X 4$ U[        XU5      4$ )a@  
Compute content and the primitive form of ``f`` in ``K[x]``.

Examples
========

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

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

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

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

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

)r0   r   r   r   )r6   r8   r   s      r>   dup_primitiver     sE    , vvqyqDxx~~w^AQ///r@   c                     U(       d  [        X5      $ [        X5      (       a  UR                  U 4$ [        XU5      nUR	                  U5      (       a  X04$ U[        XX5      4$ )af  
Compute content and the primitive form of ``f`` in ``K[X]``.

Examples
========

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

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

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

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

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

)r   r%   r0   r   r   r   )r6   rB   r8   r   s       r>   dmp_ground_primitiver     s]    , Q""!vvqyaA&Dxx~~w^AQ222r@   c                     [        X5      n[        X5      nUR                  X45      nUR                  U5      (       d  [        XU5      n [        XU5      nXPU4$ )z
Extract common content from a pair of polynomials in ``K[x]``.

Examples
========

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

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

)r   r   r   r   )r6   r9   r8   fcgcr   s         r>   dup_extractr     sT     
Q	B	Q	B
%%-C88C==11%11%19r@   c                     [        XU5      n[        XU5      nUR                  XE5      nUR                  U5      (       d  [        XX#5      n [        XX#5      nX`U4$ )z
Extract common content from a pair of polynomials in ``K[X]``.

Examples
========

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

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

)r   r   r   r   )r6   r9   rB   r8   r   r   r   s          r>   dmp_ground_extractr     sX     
A!	$B	A!	$B
%%-C88C==11(11(19r@   c                 f   UR                   (       d  UR                  (       d  [        SU-  5      e[        S5      n[        S5      nU (       d  X#4$ UR                  UR
                  //UR                  // //n[        U S   S5      nU SS  H)  n[        XTSU5      n[        U[        US5      SSU5      nM+     [        U5      nUR                  5        HW  u  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 %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"   & 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  6Mr@   c                 j    [        U 5      n [        [        U 5      S-
  SS5       H
  nX   * X'   M     U $ )z
Evaluate efficiently the composition ``f(-x)`` in ``K[x]``.

Examples
========

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

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

rx   rO   )listr3   rl   )r6   r8   r:   s      r>   
dup_mirrorr   C  s:     	QA3q6A:r2&u ' Hr@   c                     [        U 5      [        U 5      S-
  UpCn [        US-
  SS5       H  nX@U   -  XA-  sX'   nM     U $ )z
Evaluate efficiently composition ``f(a*x)`` in ``K[x]``.

Examples
========

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

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

r/   rO   r   rl   r3   )r6   ra   r8   r<   br:   s         r>   	dup_scaler   Y  sN     1gs1vz1!A1q5"b!aD&!#a " Hr@   c                     [        U 5      [        U 5      S-
  p0[        USS5       H*  n[        SU5       H  nXS-   ==   XU   -  -  ss'   M     M,     U $ )z
Evaluate efficiently Taylor shift ``f(x + a)`` in ``K[x]``.

Examples
========

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

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

r/   r   rO   r   )r6   ra   r8   r<   r:   r=   s         r>   	dup_shiftr   o  sV     7CFQJq1a_q!A!eHA$H   Hr@   c           	         U(       d  [        XS   U5      $ [        X5      (       a  U $ US   USS pT[        U5      (       a!  U  Vs/ s H  n[        XeUS-
  U5      PM     n nO[	        U 5      n U(       aa  [        U 5      S-
  n[        USS5       HB  n[        SU5       H/  n	[        X	   XBS-
  U5      n
[        X	S-      XS-
  U5      X	S-   '   M1     MD     [        X5      $ s  snf )a  
Evaluate efficiently Taylor shift ``f(X + A)`` in ``K[X]``.

Examples
========

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

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

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

>>> p.subs({x: x + 1, y: y + 2}).expand()
x**2*y + 2*x**2 + 4*x*y + 11*x + 7*y + 22
r   r/   NrO   )
r   r%   any	dmp_shiftr   rl   r3   r   r   r   )r6   ra   rB   r8   a0a1r;   r<   r:   r=   afjs              r>   r   r     s    & aD!$$!qT1QR5
2ww0131iqsA&3G	FQJq!RA1a[$QT2sA6"1U8SA#q9a% ! !
 Q? 4s   C!c                 :   U (       d  / $ [        U 5      S-
  nU S   /UR                  //pe[        SU5       H!  nUR                  [	        US   X#5      5        M#     [        U SS USS 5       H)  u  p[	        XQU5      n[        X(U5      n[        XRU5      nM+     U$ )z
Evaluate functional transformation ``q**n * f(p/q)`` in ``K[x]``.

Examples
========

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

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

r/   r   rO   N)rl   r   r3   rP   r
   zipr   r   )	r6   r|   qr8   r<   rn   Qr:   r;   s	            r>   dup_transformr     s     	A
AaD6QUUG9q1a[	2%&  AabE1QR5!A!1#A! "
 Hr@   c           	          [        U5      S::  a   [        [        U [        X5      U5      /5      $ U (       d  / $ U S   /nU SS  H  n[	        X1U5      n[        X4SU5      nM     U$ )z
Evaluate functional composition ``f(g)`` in ``K[x]``.

Examples
========

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

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

r/   r   N)rl   r   rc   r   r
   r   )r6   r9   r8   rn   r;   s        r>   dup_composer     sn     1v{(1fQlA6788		
1AqrUA!q!$  Hr@   c                     U(       d  [        XU5      $ [        X5      (       a  U $ U S   /nU SS  H  n[        XAX#5      n[        XESX#5      nM     U$ )z
Evaluate functional composition ``f(g)`` in ``K[X]``.

Examples
========

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

>>> R.dmp_compose(x*y + 2*x + y, y)
y**2 + 3*y

r   r/   N)r   r%   r   r   )r6   r9   rB   r8   rn   r;   s         r>   dmp_composer     s`     1##!	
1AqrUA!q!'  Hr@   c                    [        U 5      S-
  n[        X5      n[        U 5      n XR                  0nX1-  n[	        SU5       Ht  nUR
                  n[	        SU5       H9  n	X9-   U-
  U ;  a  M  X-
  U;  a  M  XU	-   U-
     XQU	-
     pXXi-  -
  U
-  U-  -  nM;     UR                  XU-  U-  5      XQU-
  '   Mv     [        XR5      $ )+Helper function for :func:`_dup_decompose`.r/   r   )rl   r   r&   r   r3   r0   quor'   )r6   sr8   r<   r   r9   rr:   rR   r=   r   r   s               r>   _dup_right_decomposer   
  s    A
A	BA
UUA	A1a[q!A519>5A:1uqy\1U8!#gr\"_$E  55!B'a%  Q""r@   c                     0 SpCU (       a9  [        XU5      u  pV[        U5      S:  a  g[        Xb5      X4'   XTS-   p@U (       a  M9  [        X25      $ )r   r   Nr/   )r   r   r   r'   )r6   rn   r8   r9   r:   r   r   s          r>   _dup_left_decomposer   &  sQ    qq
qQa=1!<AD!eq ! Q""r@   c                     [        U 5      S-
  n[        SU5       H2  nX#-  S:w  a  M  [        XU5      nUc  M  [        XU5      nUc  M/  XT4s  $    g)z*Helper function for :func:`dup_decompose`.r/   rx   r   N)rl   r3   r   r   )r6   r8   dfr   rn   r9   s         r>   _dup_decomposer   6  sY    	Q!B1b\6Q; q)=#A!,A}t  r@   c                 L    / n [        X5      nUb  Uu  pU/U-   nOOM  U /U-   $ )a  
Computes functional decomposition of ``f`` in ``K[x]``.

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

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

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

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

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

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

Examples
========

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

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

References
==========

.. [1] [Kozen89]_

)r   )r6   r8   Frb   rn   s        r>   dup_decomposer   I  sD    H 	A
%DAaA  37Nr@   c                     UR                   (       d  UR                  (       a  [        XU5      $ UR                  (       a  [	        XU5      $ [        S5      e)aI  
Convert polynomial from ``K(a)[X]`` to ``K[a,X]``.

Examples
========

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

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

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

z3computation can be done only in an algebraic domain)is_GaussianRingis_GaussianField_dmp_alg_inject_gaussianis_Algebraic_dmp_alg_inject_algr+   )r6   rB   r8   s      r>   dmp_alg_injectr   {  sB    , 	A..'a00	
"1++OPPr@   c                 
   [        X5      0 p0U R                  5        H:  u  pEUR                  UR                  pvU(       a  XcSU-   '   U(       d  M3  XsSU-   '   M<     [	        X1S-   UR
                  5      nXS-   UR
                  4$ )+Helper function for :func:`dmp_alg_inject`.)r   )r/   r/   )r   r   xyr   dom)	r6   rB   r8   rn   f_monomr9   r   r   r   s	            r>   r   r     sw    qbqggi
ssACC1 !dWn1 !dWn   	aQ&A!eQUU?r@   c                     [        X5      0 p0U R                  5        H2  u  pEUR                  5       R                  5        H  u  pgXsXd-   '   M     M4     [        X1S-   UR                  5      nXS-   UR                  4$ )r   r/   )r   r   to_dictr   r   )	r6   rB   r8   rn   r   r9   g_monomr;   r   s	            r>   r   r     sn    qbqggi
))+++-JG#$g  .   	aQ&A!eQUU?r@   c           
          SSK Jn  [        XU5      u  pEnUR                  R	                  5       n[        U[        [        SUS-   5      5      SU5      nU" XHXV5      $ )a#  
Convert algebraic coefficients to integers in ``K[X]``.

Examples
========

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

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

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

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

r/   )dmp_resultantr   )euclidtoolsr   r   modto_listr)   r   r3   )	r6   rB   r8   r   r   rC   K2p_aP_As	            r>   dmp_liftr     sR    ( +aA&HA"
%%--/C
c4aQ0!R
8C''r@   c                   ^ U4S jnTR                   (       d"  TR                  (       d  TR                  (       a  TR                  nOTR                  (       a  TR
                  R                  (       a  UnOTR                  (       d  TR                  (       a  [        TR                  5      S:X  a  TR                  R                   (       d,  TR                  R                  (       d  TR                  (       a?  TR                  S   R                  (       a!  TR                  S   R                  (       a  UnO[        ST-  5      eTR                  SpTU  H"  nU" Xd-  5      (       a  US-  nU(       d  M   UnM$     U$ )z
Compute the number of sign variations of ``f`` in ``K[x]``.

Examples
========

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

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

c                 N   > U (       d  g[        TR                  U 5      S:  5      $ )NFr   )boolto_sympy)ra   r8   s    r>   is_negative_sympy.dup_sign_variations.<locals>.is_negative_sympy  s#     

1)**r@   r/   r   z-sign variation counting not supported over %s)ry   r   is_RRis_negativeis_AlgebraicFieldextis_comparableis_PolynomialRingis_FractionFieldrl   symbolsr   is_transcendentalr+   r0   )r6   r8   r   r   prevrS   rR   s    `     r>   dup_sign_variationsr     s    
+  	ww!''QWWmm	
		!4!4'!"4"4#aii.A:M55;;!%%++)<)<
))A,
(
(QYYq\-G-G (IAMNNffa!uz""FA5D  Hr@   Nc           
         Uc$  UR                   (       a  UR                  5       nOUnUR                  nU  H#  nUR                  XAR	                  U5      5      nM%     UR                  U5      (       a  U(       d  X@4$ U[        XU5      4$ U  Vs/ s H4  oQR                  U5      UR                  XAR	                  U5      5      -  PM6     n nU(       d  U[        XU5      4$ X@4$ s  snf )a  
Clear denominators, i.e. transform ``K_0`` to ``K_1``.

Examples
========

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

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

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

)	has_assoc_Ringget_ringr   lcmdenomr   r   numerr   )r6   K0K1r`   commonr;   s         r>   dup_clear_denomsr     s    $ 
zBB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`.r/   )r   r   r   _rec_clear_denoms)r9   rC   r   r   r   r;   rH   s          r>   r  r  8  si    VVFAVVFHHQK0F  M EAVVF$5aB$CDF  Mr@   c                     U(       d
  [        XX4S9$ Uc$  UR                  (       a  UR                  5       nOUn[        XX#5      nUR	                  U5      (       d  [        XX5      n U(       d  XP4$ U[        XX#5      4$ )a*  
Clear denominators, i.e. transform ``K_0`` to ``K_1``.

Examples
========

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

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

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

)r`   )r   r   r   r  r   r   r   )r6   rB   r   r   r`   r   s         r>   dmp_clear_denomsr  H  sv    $ r;;	zBBqR,F99V1a,y{1000r@   c                    UR                  [        X5      5      /nUR                  UR                  UR                  /n[	        [        [        U5      5      5      n[        SUS-   5       HW  n[        X2" S5      U5      n[        U [        X25      U5      n[        [        XxU5      XB5      n[        U[        U5      U5      nMY     U$ )a  
Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

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

Examples
========

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

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

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

r/   rx   )revertr!   r   r0   r{   _ceil_log2r3   r   r
   r   r   r   r   r   )	r6   r<   r8   r9   rn   Nr:   ra   r   s	            r>   
dup_revertr	  n  s    ( 
&,	 A	
AE%(OA1a!e_1adA&Awq}a(GA!$a+q*Q-+	  Hr@   c                 >    U(       d  [        XU5      $ [        X5      e)z
Compute ``f**(-1)`` mod ``x**n`` using Newton iteration.

Examples
========

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

)r	  r*   )r6   r9   rB   r8   s       r>   
dmp_revertr    s     !"")!//r@   )NF)c__doc__sympy.polys.densearithr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   sympy.polys.densebasicr   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   sympy.polys.polyerrorsr*   r+   mathr,   r  r-   r  r?   rD   rF   rM   rT   rV   rX   r]   rc   re   rg   ri   rk   rq   rs   rv   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r	  r   r@   r>   <module>r     s\   N          
 .@ FL/,(V,^G*04:G*0
1(@L/4D@(E0*:!-H'T*Z0B!3H441h,,.(V>::#8# &/dQ< 
(<4n*Z #1LD0r@   