ó
    Š*£håé  ã            
       óD  • S r SSKJrJr  SSKJrJrJr  SSKJ	r	  SSK
Jr  SSKJrJrJrJr  SSKJr  SSKJrJrJr  SS	KJr  SS
K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'  SSK(J)r)  SSKJ*r*  SSK+r+S r,S r-S r.S r/S r0S r1S r2S r3S r4S r5S r6S r7S r8S r9S r:S r;S r<SMS  jr=S! r>S" r?S# r@S$ rAS% rBS& rCS' rDS( rES) rFS* rGS+ rHS, rIS- rJS. rKS/ rLS0 rMS1 rNS2 rOS3 rPS4 rQS5 rRS6 rSS7 rTS8 rUS9 rVS: rWS; rXS< rYS= rZSNS> jr[S? r\S@SASBSCSDSESFSGSHSI.	r]SJ r^SK r_SL r`g)Oa9  Power series evaluation and manipulation using sparse Polynomials

Implementing a new function
---------------------------

There are a few things to be kept in mind when adding a new function here::

    - The implementation should work on all possible input domains/rings.
      Special cases include the ``EX`` ring and a constant term in the series
      to be expanded. There can be two types of constant terms in the series:

        + A constant value or symbol.
        + A term of a multivariate series not involving the generator, with
          respect to which the series is to expanded.

      Strictly speaking, a generator of a ring should not be considered a
      constant. However, for series expansion both the cases need similar
      treatment (as the user does not care about inner details), i.e, use an
      addition formula to separate the constant part and the variable part (see
      rs_sin for reference).

    - All the algorithms used here are primarily designed to work for Taylor
      series (number of iterations in the algo equals the required order).
      Hence, it becomes tricky to get the series of the right order if a
      Puiseux series is input. Use rs_puiseux? in your function if your
      algorithm is not designed to handle fractional powers.

Extending rs_series
-------------------

To make a function work with rs_series you need to do two things::

    - Many sure it works with a constant term (as explained above).
    - If the series contains constant terms, you might need to extend its ring.
      You do so by adding the new terms to the rings as generators.
      ``PolyRing.compose`` and ``PolyRing.add_gens`` are two functions that do
      so and need to be called every time you expand a series containing a
      constant term.

Look at rs_sin and rs_series for further reference.

é    )ÚQQÚEX)ÚPolyElementÚringÚsring)ÚPuiseuxPoly)ÚDomainError)Úmonomial_minÚmonomial_mulÚmonomial_divÚmonomial_ldiv)Úifac)Ú	PoleErrorÚFunctionÚExpr)ÚRational)Úigcd)ÚsinÚcosÚtanÚatanÚexpÚatanhÚasinhÚtanhÚlogÚceilingÚsinhÚcosh)Úas_int)Úgiant_stepsNc                 ó$  • [        U R                  5       5      nUR                  5         U R                  5       nU R                  nUR
                  nU R                  5       nU R                  5       n[        Xe5       H  u  pxX„X'S   -
  4'   M     U$ )ap  
Compute ``x**n * p1(1/x)`` for a univariate polynomial ``p1`` in ``x``.

Examples
========

>>> from sympy.polys.domains import ZZ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import _invert_monoms
>>> R, x = ring('x', ZZ)
>>> p = x**2 + 2*x + 3
>>> _invert_monoms(p)
3*x**2 + 2*x + 1

See Also
========

sympy.polys.densebasic.dup_reverse
r   )	ÚlistÚitemsÚsortÚdegreer   ÚzeroÚ
listcoeffsÚ
listmonomsÚzip)	Úp1ÚtermsÚdegÚRÚpÚcvÚmvÚmviÚcvis	            ÚT/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/polys/ring_series.pyÚ_invert_monomsr5   =   su   € ô( �—‘“Ó€EØ	‡J�J„LØ
�)‰)‹+€CØ
�‰€AØ	�‰€AØ	�‰‹€BØ	�‰‹€BÜ˜–K‰ˆØ ˆ3�Q‘‰<ˆ/Óñ  à€Hó    c                 ód   • [        S[        R                  " U 5      5      nUS   S:w  a  S/U-   nU$ )z8Return a list of precision steps for the Newton's methodé   r   )r!   ÚmathÚceil)ÚtargetÚress     r4   Ú_giant_stepsr=   \   s4   € ô �aœŸš 6Ó*Ó
+€CØ
ˆ1�v�ƒ{Øˆc�C‰iˆØ€Jr6   c                 ó–   • U R                   n0 nUR                  R                  U5      nU  H  nXe   U:¼  a  M  X   XF'   M     U" U5      $ )a|  
Truncate the series in the ``x`` variable with precision ``prec``,
that is, modulo ``O(x**prec)``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_trunc
>>> R, x = ring('x', QQ)
>>> p = x**10 + x**5 + x + 1
>>> rs_trunc(p, x, 12)
x**10 + x**5 + x + 1
>>> rs_trunc(p, x, 10)
x**5 + x + 1
)r   ÚgensÚindex)r+   ÚxÚprecr.   r/   ÚiÚexp1s          r4   Úrs_truncrE   d   sM   € ð$ 	�‰€AØ
€AØ	�‰�‰�Q‹€AÛˆØ‰7�d‹?ÙØ‘(ˆ‹ñ ñ ˆQ‹4€Kr6   c                 óÒ   • U R                   R                  R                  U5      nU R                  5        H.  nX2   [	        X2   5      :w  a    gX2   S:  d  M"  [        SU-  5      e   g)ah  
Test if ``p`` is Puiseux series in ``x``.

Raise an exception if it has a negative power in ``x``.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.puiseux import puiseux_ring
>>> from sympy.polys.ring_series import rs_is_puiseux
>>> R, x = puiseux_ring('x', QQ)
>>> p = x**QQ(2,5) + x**QQ(2,3) + x
>>> rs_is_puiseux(p, x)
True
Tr   zThe series is not regular in %sF)r   r?   r@   Ú
itermonomsÚintÚ
ValueError)r/   rA   r@   Úks       r4   Úrs_is_puiseuxrK      s^   € ð" �F‰F�K‰K×Ñ˜aÓ €EØ�\‰\Ž^ˆØ‰8”s˜1™8“}Ó$ÙØ‰8�a�<ÜÐ>ÀÑBÓCÐCñ	 ð
 r6   c           
      ód  • UR                   R                  R                  U5      nSnU H  nXd   n[        U[        5      (       a-  UR                  5       u  p‰[        XY-  [        XY5      -  5      nMI  U[        U5      :w  d  MZ  UR                  n	[        XY-  [        XY5      -  5      nM�     US:w  ao  [        XU5      n
U " X¢X5-  5      n[        SU5      n[        U[        5      (       a(  [        U Vs/ s H  n[        XÔU5      PM     sn5      nU$ [        X´U5      n U$ U " XU5      nU$ s  snf )aª  
Return the puiseux series for `f(p, x, prec)`.

To be used when function ``f`` is implemented only for regular series.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.puiseux import puiseux_ring
>>> from sympy.polys.ring_series import rs_puiseux, rs_exp
>>> R, x = puiseux_ring('x', QQ)
>>> p = x**QQ(2,5) + x**QQ(2,3) + x
>>> rs_puiseux(rs_exp,p, x, 1)
1 + x**(2/5) + x**(2/3) + 1/2*x**(4/5)
é   )r   r?   r@   Ú
isinstancer   Úas_numer_denomrH   r   ÚdenominatorÚpow_xinr   Útuple)Úfr/   rA   rB   r@   ÚnrJ   ÚpowerÚnumÚdenr+   ÚrÚn1Úrxs                 r4   Ú
rs_puiseuxr[   ˜   s  € ð" �F‰F�K‰K×Ñ˜aÓ €EØ	€AÛˆØ‘ˆÜ�eœX×&Ñ&Ø×+Ñ+Ó-‰HˆCÜ�A‘EœT !›\Ñ)Ó*ŠAØ”c˜%“jÕ Ø×#Ñ#ˆCÜ�A‘EœT !›\Ñ)Ó*ŠAñ ð 	ˆAƒvÜ�Q˜qÓ!ˆÙˆb�T‘VÓˆÜ��1‹XˆÜ�aœ×ÑÜ¹Ó:º°"”w˜r¨"Ö-¹Ñ:Ó;ˆAð
 €Hô ˜ "Ó%‰Að €Hñ ˆa�D‹MˆØ€Hùò ;s   Ã4D-c                 ó¼  • UR                   R                  R                  U5      nSnU Hm  nXu   n[        U[        5      (       a$  UR                  5       u  pšXj-  [        Xj5      -  nM@  U[        U5      :w  d  MQ  UR                  n
Xj-  [        Xj5      -  nMo     US:w  a2  [        XU5      nU " X²X4U-  5      n[        SU5      n[        XÅU5      nU$ U " XX45      nU$ )z{
Return the puiseux series for `f(p, q, x, prec)`.

To be used when function ``f`` is implemented only for regular series.
rM   )r   r?   r@   rN   r   rO   r   rH   rP   rQ   r   )rS   r/   ÚqrA   rB   r@   rT   rJ   rU   rV   rW   r+   rX   rY   s                 r4   Úrs_puiseux2r^   ¿   sÜ   € ð �F‰F�K‰K×Ñ˜aÓ €EØ	€AÛˆØ‘ˆÜ�eœX×&Ñ&Ø×+Ñ+Ó-‰HˆCØ‘œ˜a›Ñ%ŠAØ”c˜%“jÕ Ø×#Ñ#ˆCØ‘œ˜a›Ñ%ŠAñ ð 	ˆAƒvÜ�Q˜qÓ!ˆÙˆb�Q˜Q™ÓˆÜ��1‹XˆÜ�A˜bÓ!ˆð €Hñ ˆa�AÓˆØ€Hr6   c                 ó  ^• U R                   n0 nUR                  UR                   R                  :w  d  XAR                   :w  a  [        S5      eUR                  R	                  U5      m[        U[        [        45      (       d  [        S5      eXAR                   :X  aä  UR                  nUR                  5       nUR                  U4S jS9  UR                  S:X  aK  U R                  5        H6  u  p‰U H+  u  p«US   U
S   -   nXÃ:  a  U4nU" US5      X›-  -   X\'   M*    M4     M8     OZUR                  nU R                  5        H:  u  p‰U H/  u  p«UT   U
T   -   U:  a  U" XŠ5      nU" US5      X›-  -   X\'   M.    M8     M<     U" U5      $ )a€  
Return the product of the given two series, modulo ``O(x**prec)``.

``x`` is the series variable or its position in the generators.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_mul
>>> R, x = ring('x', QQ)
>>> p1 = x**2 + 2*x + 1
>>> p2 = x + 1
>>> rs_mul(p1, p2, x, 3)
3*x**2 + 3*x + 1
z!p1 and p2 must have the same ringzp2 must be a polynomialc                 ó   >• U S   T   $ ©Nr   © ©ÚeÚivs    €r4   Ú<lambda>Úrs_mul.<locals>.<lambda>ô   s   ø€  ! A¡$ r¢(r6   ©ÚkeyrM   r   )r   Ú	__class__rI   r?   r@   rN   r   r   Úgetr,   r%   ÚngensÚ	itertermsr   )r+   Úp2rA   rB   r.   r/   rk   Úitems2rD   Úv1Úexp2Úv2r   r   re   s                 @r4   Úrs_mulrs   Ø   s`  ø€ ð$ 	�‰€AØ
€AØ‡{�{�b—g‘g×'Ñ'Ó'¨1·±«<ÜÐ<Ó=Ð=Ø	
�‰�‰�a‹€BÜ�bœ;¬Ð4×5Ñ5ÜÐ2Ó3Ð3Ø�G‰Gƒ|Ø�e‰eˆØ—‘“ˆØ�‰Ô*ˆÑ+Ø�7‰7�a‹<ØŸL™LžN‘�Û &‘H�DØ˜q™' D¨¡GÑ+�CØ“zØ"˜g˜Ù!$ S¨!£¨r©uÑ!4˜›âó !'ò +ð Ÿ>™>ˆLØŸL™LžN‘�Û &‘H�DØ˜B‘x $ r¡(Ñ*¨TÓ1Ù*¨4Ó6˜Ù!$ S¨!£¨r©uÑ!4˜›âó !'ñ +ñ ˆQ‹4€Kr6   c                 óž  ^• U R                   n0 nUR                  R                  U5      mUR                  nU R	                  5       nUR                  U4S jS9  UR                  n[        [        U5      5       HK  nXh   u  pš[        U5       H3  nXk   u  pÍU	T   UT   -   U:  a  U" Xœ5      nU" US5      X­-  -   XN'   M2    MI     MM     UR                  5        VVs0 s H  u  nnUSU-  _M     nnnUR                  nU R                  5        H/  u  nnSUT   -  U:  d  M  U" UU5      nU" US5      US-  -   UU'   M1     U" U5      $ s  snnf )a  
Square the series modulo ``O(x**prec)``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_square
>>> R, x = ring('x', QQ)
>>> p = x**2 + 2*x + 1
>>> rs_square(p, x, 3)
6*x**2 + 4*x + 1
c                 ó   >• U S   T   $ ra   rb   rc   s    €r4   rf   Úrs_square.<locals>.<lambda>  s   ø€ ˜Q˜q™T "šXr6   rh   r   r8   )r   r?   r@   rk   r,   r%   r   ÚrangeÚlenr$   rm   )r+   rA   rB   r.   r/   rk   r$   r   rC   rD   rp   Újrq   rr   r   ÚmÚvÚexpvÚe2re   s                      @r4   Ú	rs_squarer~   
  sB  ø€ ð 	�‰€AØ
€AØ	
�‰�‰�a‹€BØ
�%‰%€CØ�H‰H‹J€EØ	‡J�JÔ%€JÑ&Ø—>‘>€LÜ”3�u“:ÖˆØ‘8‰ˆÜ�q–ˆAØ‘x‰HˆDØ�B‰x˜$˜r™(Ñ" TÓ)Ù" 4Ó.�Ù˜S !› r¡uÑ,�“âó ñ ð ŸG™GœIÔ&šI‘D�A�qˆˆAˆa‰CŠ™I€AÑ&Ø
�%‰%€CØ—<‘<–>‰ˆˆaØˆT�"‰X‰:˜ÕÙ˜d DÓ)ˆBÙ˜˜A“J  A¡Ñ%ˆAˆb‹Eñ "ñ ˆQ‹4€Kùó 	's   ÃE	c                 óš  • U R                   n[        U[        5      (       a^  [        UR                  5      n[        UR
                  5      nUS:w  a   [        XX#5      nUS:w  a  [        XuX#5      nU$ [        XX#5      nU$ [        U5      nUS:X  a  U (       a  U" S5      $ [        S5      eUS:  a  [        X* X#5      n [        XU5      $ US:X  a  [        XU5      $ US:X  a  [        XU5      $ US:X  a  [        XU5      n[        XX#5      $ U" S5      n	 US-  (       a  [        X	X#5      n	US-  nU(       d   U	$ [        XU5      n US-  nM8  )a  
Return ``p1**n`` modulo ``O(x**prec)``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_pow
>>> R, x = ring('x', QQ)
>>> p = x + 1
>>> rs_pow(p, 4, x, 3)
6*x**2 + 4*x + 1
rM   r   z0**0 is undefinedr8   é   )r   rN   r   rH   r/   r]   Úrs_nth_rootÚrs_powr    rI   Úrs_series_inversionrE   r~   rs   )
r+   rT   rA   rB   r.   ÚnpÚnqr<   rn   r/   s
             r4   r‚   r‚   1  sW  € ð 	�‰€AÜ�!”X×ÑÜ�—‘‹XˆÜ�—‘‹XˆØ�‹7Ü˜b aÓ.ˆCØ�Q‹wÜ˜S aÓ.�ð ˆ
ô ˜ Ó)ˆCØˆ
äˆq‹	€AØˆAƒvÞÙ�Q“4ˆKäÐ0Ó1Ð1Øˆ1ƒuÜ�B˜˜AÓ$ˆÜ" 2¨$Ó/Ð/ØˆAƒvÜ˜˜tÓ$Ð$ØˆAƒvÜ˜ Ó%Ð%ØˆAƒvÜ�r˜dÓ#ˆÜ�b˜aÓ&Ð&Ù	ˆ!‹€AØ
Øˆq�5Ü�r˜aÓ&ˆAØ�‰FˆAÞØð €Hô �r˜dÓ#ˆØ�‰Fˆñ r6   c                 óˆ  • U R                   nUR                  nU" S5      n[        U5       H  nUR                  U   XgS4'   M     U H  nX   XdR	                  U5      S4'   M     U" S5      n	[        U R                  5       5      n
U
 Hµ  nU" S5      n[        U5       H’  nX·   nUS:X  a  M  X}4U;  al  [        US5      u  pïUS:X  a  X~4U;   a  [        XgU4   X#5      XgU4'   O<X}S-
  4U;   a  [        XgUS-
  4   XgS4   X#5      XgU4'   O[        XgS4   XÒU5      XgU4'   [        XÆX}4   X#5      nM”     XœX   -  -  n	M·     U	$ )aM  
Substitution with truncation according to the mapping in ``rules``.

Return a series with precision ``prec`` in the generator ``x``

Note that substitutions are not done one after the other

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_subs
>>> R, x, y = ring('x, y', QQ)
>>> p = x**2 + y**2
>>> rs_subs(p, {x: x+ y, y: x+ 2*y}, x, 3)
2*x**2 + 6*x*y + 5*y**2
>>> (x + y)**2 + (x + 2*y)**2
2*x**2 + 6*x*y + 5*y**2

which differs from

>>> rs_subs(rs_subs(p, {x: x+ y}, x, 3), {y: x+ 2*y}, x, 3)
5*x**2 + 12*x*y + 8*y**2

Parameters
----------
p : :class:`~.PolyElement` Input series.
rules : ``dict`` with substitution mappings.
x : :class:`~.PolyElement` in which the series truncation is to be done.
prec : :class:`~.Integer` order of the series after truncation.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_subs
>>> R, x, y = ring('x, y', QQ)
>>> rs_subs(x**2+y**2, {y: (x+y)**2}, x, 3)
 6*x**2*y**2 + x**2 + 4*x*y**3 + y**4
r   rM   r8   )r   rl   rw   r?   r@   ÚsortedÚkeysÚdivmodr~   rs   r‚   )r/   ÚrulesrA   rB   r.   rl   ÚdrC   Úvarr+   Úp_keysr|   rn   rU   r]   rX   s                   r4   Úrs_subsrŽ   g  sg  € ðP 	
�‰€AØ�G‰G€EÙ	ˆ!‹€AÜ�5Ž\ˆØ—F‘F˜1‘Iˆˆaˆ&‹	ñ ãˆØ$™zˆ�7‰7�3‹<˜Ð
Óñ á	
ˆ1‹€BÜ�A—F‘F“HÓ€FÛˆÙˆq‹TˆÜ�u–ˆAØ‘GˆEØ˜‹zÙØˆz Ó"Ü˜e QÓ'‘�Ø˜“6˜q˜f¨›kÜ$-¨a°A°©i¸Ó$A�A˜%�j’MØ ™�^ qÓ(Ü$*¨1°¸±¨^Ñ+<¸aÀAÀ¹iØ+,ó%4�A˜%�j’Mô %+¨1°¨V©9°eÀÓ$E�A˜%�j‘MÜ˜˜q˜j™M¨1Ó3ŠBñ ð 	�‘‰jÑŠñ! ð" €Ir6   c                 óÖ   ^^• U R                   nUR                  R                  U5      nUR                  mS/UR                  -  nSXC'   [        U5      m[        UU4S jU  5       5      $ )a  
Check if ``p`` has a constant term in ``x``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import _has_constant_term
>>> R, x = ring('x', QQ)
>>> p = x**2 + x + 1
>>> _has_constant_term(p, x)
True
r   rM   c              3   óB   >#   • U  H  n[        UT5      T:H  v •  M     g 7f©N)r
   )Ú.0r|   ÚmivÚzms     €€r4   Ú	<genexpr>Ú%_has_constant_term.<locals>.<genexpr>À  s   øé € Ð;º°Œ|˜D #Ó&¨"Ö,ºùs   ƒ)r   r?   r@   Ú
zero_monomrl   rR   Úany)r/   rA   r.   re   Úar“   r”   s        @@r4   Ú_has_constant_termrš   «  sX   ù€ ð 	
�‰€AØ	
�‰�‰�a‹€BØ	
�‰€BØ	
ˆˆA�G‰G‰€AØ€A�EÜ
�‹(€CÜÕ;¹Ó;Ó;Ð;r6   c                 óþ   • U R                   nUR                  R                  U5      nUR                  nS/UR                  -  nSXS'   [        U5      nSnU  H"  n[        X†5      U:X  d  M  Xr" X€U   05      -  nM$     U$ )zÍReturn constant term in p with respect to x

Note that it is not simply `p[R.zero_monom]` as there might be multiple
generators in the ring R. We want the `x`-free term which can contain other
generators.
r   rM   )r   r?   r@   r—   rl   rR   r
   )	r/   rA   r.   rC   r”   r™   r“   Úcr|   s	            r4   Ú_get_constant_termr�   Â  s~   € ð 	
�‰€AØ	�‰�‰�Q‹€AØ	
�‰€BØ	
ˆˆA�G‰G‰€AØ€A�DÜ
�‹(€CØ	€AÛˆÜ˜Ó" bÕ(Ø��D˜D™'�?Ó#Ñ#ŠAñ ð €Hr6   c                 ó    ^• U R                   R                  R                  U5      m[        U U4S jS9T   nUS:  a  [	        SU-  5      eTU4$ )Nc                 ó   >• U T   $ r‘   rb   ©rJ   r@   s    €r4   rf   Ú#_check_series_var.<locals>.<lambda>×  ó	   ø€ ˜Q˜ušXr6   rh   r   z7Asymptotic expansion of %s around [oo] not implemented.)r   r?   r@   Úminr   )r/   rA   Únamerz   r@   s       @r4   Ú_check_series_varr¥   Õ  sW   ø€ Ø�F‰F�K‰K×Ñ˜aÓ €EÜˆAÔ%Ñ& uÑ-€AØˆ1ƒuÜð 'Ø)-ñ.ó /ð 	/à�!ˆ8€Or6   c                 óR  • [        X5      (       a  [        [        XU5      $ U R                  nUR                  nX   nU[        U5      :X  a  [        U5      nX@;  a  [        S5      e[        X-
  U5      (       a  [        S5      eUR                  R                  U5      (       d  [        SU SUR                   35      eU" S5      nUR                  [        L a  SnXV:w  a  U" S5      U-  nOU" S5      n[        U5       H!  nS[        XpX5      -
  n	U[        XyX5      -   nM#     U$ )aQ  
Univariate series inversion ``1/p`` modulo ``O(x**prec)``.

The Newton method is used.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import _series_inversion1
>>> R, x = ring('x', QQ)
>>> p = x + 1
>>> _series_inversion1(p, x, 4)
-x**3 + x**2 - x + 1
úNo constant term in seriesz8p cannot contain a constant term depending on parameterszConstant term z must be a unit in rM   )rK   r[   Ú_series_inversion1r   r—   rH   rI   rš   ÚdomainÚis_unitr   r=   rs   )
r/   rA   rB   r.   r”   rœ   Úoner+   ÚprecxÚts
             r4   r¨   r¨   Ý  s  € ô" �Q×ÑÜÔ,¨a°DÓ9Ð9Ø	�‰€AØ	
�‰€BØ	‰€Að Œs�4‹yÓÜ�4‹yˆà	ƒ{ÜÐ5Ó6Ð6Ü˜!™% ×#Ñ#Üð &ó 'ð 	'à�8‰8×Ñ˜A×ÑÜ˜>¨!¨Ð,?ÀÇÁ¸zÐJÓKÐKá
ˆA‹$€CØ‡x�x”2‚~ØˆØƒxÙˆq‹T�!‰V‰áˆq‹TˆÜ˜dÖ#ˆØ”�r˜aÓ'Ñ'ˆØ”&˜ Ó)Ñ)Šñ $ð €Ir6   c                 óŽ  ^• U R                   nXR                  :X  a  [        eUR                  nUR                  R                  U5      m[        U U4S jS9T   nU(       a  [        U TU* 5      n X%-   nX@;  a  [        S5      e[        X U   -
  U5      (       a  [        S5      e[        XU5      nUS:w  a  [        UTU* 5      nU$ )aÅ  
Multivariate series inversion ``1/p`` modulo ``O(x**prec)``.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_series_inversion
>>> R, x, y = ring('x, y', QQ)
>>> rs_series_inversion(1 + x*y**2, x, 4)
-x**3*y**6 + x**2*y**4 - x*y**2 + 1
>>> rs_series_inversion(1 + x*y**2, y, 4)
-x*y**2 + 1
>>> rs_series_inversion(x + x**2, x, 4)
x**3 - x**2 + x - 1 + x**(-1)
c                 ó   >• U T   $ r‘   rb   r    s    €r4   rf   Ú%rs_series_inversion.<locals>.<lambda>$  r¢   r6   rh   r§   z>p - p[0] must not have a constant term in the series variablesr   )r   r'   ÚZeroDivisionErrorr—   r?   r@   r£   Úmul_xinÚNotImplementedErrorrš   r¨   )r/   rA   rB   r.   r”   rz   rX   r@   s          @r4   rƒ   rƒ     sÁ   ø€ ð$ 	
�‰€AØ�F‰Fƒ{ÜÐØ	
�‰€BØ�F‰F�L‰L˜‹O€EÜˆAÔ%Ñ& uÑ-€AÞÜ�A�u˜q˜bÓ!ˆØ‰xˆØ	ƒ{Ü!Ð">Ó?Ð?ä˜! ™e™) Q×'Ñ'Ü!ð #9ó :ð 	:ä˜1 Ó&€AØˆAƒvÜ�A�u˜q˜bÓ!ˆØ€Hr6   c                 óº   • Uu  p#U R                   nS/UR                  -  nX5U'   [        U5      nU" S5      nU  H  nXr   U:X  d  M  X   U[        Xu5      '   M     U$ )z2Coefficient of `x_i**j` in p, where ``t`` = (i, j)r   )r   rl   rR   r   )r/   r­   rC   ry   r.   Úexpv1r+   r|   s           r4   Ú_coefficient_tr¶   3  se   € à�D€AØ	�‰€AØˆC�—‘‰K€EØˆ!�HÜ�%‹L€EÙ	
ˆ1‹€BÛˆØ‰7�a�<Ø,-©GˆBŒ|˜DÓ(Ó)ñ ð €Ir6   c                 óä  • [        X5      (       a  [        eU R                  nUR                  R	                  U5      nU" U5      nUR                  R	                  U5      n[        X5      (       a  [        S5      e[        XS45      nUR                  nX‡;   a  [        U5      S:X  d   eXx   nX7-  n	[        SU5       H-  n
[        XU	0X:S-   5      n[        X¶U
45      X:-  -  nX›U-  -  n	M/     U	$ )aÎ  
Reversion of a series.

``p`` is a series with ``O(x**n)`` of the form $p = ax + f(x)$
where $a$ is a number different from 0.

$f(x) = \sum_{k=2}^{n-1} a_kx_k$

Parameters
==========

  a_k : Can depend polynomially on other variables, not indicated.
  x : Variable with name x.
  y : Variable with name y.

Returns
=======

Solve $p = y$, that is, given $ax + f(x) - y = 0$,
find the solution $x = r(y)$ up to $O(y^n)$.

Algorithm
=========

If $r_i$ is the solution at order $i$, then:
$ar_i + f(r_i) - y = O\left(y^{i + 1}\right)$

and if $r_{i + 1}$ is the solution at order $i + 1$, then:
$ar_{i + 1} + f(r_{i + 1}) - y = O\left(y^{i + 2}\right)$

We have, $r_{i + 1} = r_i + e$, such that,
$ae + f(r_i) = O\left(y^{i + 2}\right)$
or $e = -f(r_i)/a$

So we use the recursion relation:
$r_{i + 1} = r_i - f(r_i)/a$
with the boundary condition: $r_1 = y$

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_series_reversion, rs_trunc
>>> R, x, y, a, b = ring('x, y, a, b', QQ)
>>> p = x - x**2 - 2*b*x**2 + 2*a*b*x**2
>>> p1 = rs_series_reversion(p, x, 3, y); p1
-2*y**2*a*b + 2*y**2*b + y**2 + y
>>> rs_trunc(p.compose(x, p1), y, 3)
y
z9p must not contain a constant term in the series variablerM   r8   )rK   r³   r   r?   r@   rš   rI   r¶   r—   rx   rw   rŽ   )r/   rA   rT   Úyr.   ÚnxÚnyr™   r”   rX   rC   Úsps               r4   Úrs_series_reversionr¼   @  sì   € ôh �Q×ÑÜ!Ð!Ø	�‰€AØ	
�‰�‰�a‹€BÙ	ˆ!‹€AØ	
�‰�‰�a‹€BÜ˜!×ÑÜð $ó %ð 	%ä�q˜q˜'Ó"€AØ	
�‰€BØ‹7”s˜1“v “{Ð"Ð"Ø	‰€AØ	‰€AÜ�1�aŽ[ˆÜ�Q˜A˜  q¡5Ó)ˆÜ˜B Q Ó(¨©Ñ-ˆØ	�‰T‰	Šñ ð €Hr6   c                 ó.  • U R                   n[        U5      nU(       d;  U" S5      nUS   U-  n[        SU5       H  n	[        XpX#5      nX�U	   U-  -  nM     U$ [	        [
        R                  " U5      S-   5      n
[        Xj5      u  p¼U(       a  US-  nU" S5      /nU" S5      n[        U 5      S:  a1  [        SU
5       H   n	[        XpX#5      nUR                  U5        M"     OK[        SU
5       H;  n	U	S-  S:X  a  [        XÙS-     X#5      nO[        XpX#5      nUR                  U5        M=     [        US   XU5      nU" S5      nU" S5      n[        US-
  5       HV  nU
U-  nX   n[        SU
5       H  nUXU-      UU   -  -  nM     [        UXòU5      nUU-  n[        XþX#5      nU(       a  MV    O   US-
  nU
U-  nXÆ:  aM  X   U" S5      -  n[        SU
5       H  nUU-   U:¼  a    OUXU-      UU   -  -  nM      [        UXòU5      nUU-  nU$ )aÿ  
Return a series `sum c[n]*p**n` modulo `O(x**prec)`.

It reduces the number of multiplications by summing concurrently.

`ax = [1, p, p**2, .., p**(J - 1)]`
`s = sum(c[i]*ax[i]` for i in `range(r, (r + 1)*J))*p**((K - 1)*J)`
with `K >= (n + 1)/J`

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_series_from_list, rs_trunc
>>> R, x = ring('x', QQ)
>>> p = x**2 + x + 1
>>> c = [1, 2, 3]
>>> rs_series_from_list(p, c, x, 4)
6*x**3 + 11*x**2 + 8*x + 6
>>> rs_trunc(1 + 2*p + 3*p**2, x, 4)
6*x**3 + 11*x**2 + 8*x + 6
>>> pc = R.from_list(list(reversed(c)))
>>> rs_trunc(pc.compose(x, p), x, 4)
6*x**3 + 11*x**2 + 8*x + 6

See Also
========

sympy.polys.rings.PolyRing.compose

rM   r   é   r8   éÿÿÿÿ)
r   rx   rw   rs   rH   r9   Úsqrtr‰   Úappendr~   )r/   rœ   rA   rB   Úconcurr.   rT   r]   ÚsrC   ÚJÚKrX   ÚaxÚpjÚbrJ   Ús1ry   s                      r4   Úrs_series_from_listrÊ   ˆ  s3  € ðB 	
�‰€AÜˆA‹€AÞÙˆa‹DˆØˆa‰D�‰FˆÜ�q˜!–ˆAÜ�q˜QÓ%ˆAØ�1‘�a‘‰KŠAñ ð ˆÜŒD�IŠI�a‹L˜1ÑÓ€AÜ�!‹<�D€AÞØ	ˆQ‰ˆÙ
ˆA‹$ˆ€BÙ	ˆ!‹€AÜ
ˆ1ƒv�ƒ{Ü�q˜!–ˆAÜ�q˜QÓ%ˆAØ�I‰I�aŽLò ô �q˜!–ˆAØ�1‰u˜‹zÜ˜b A¡™h¨Ó0‘ä˜1 Ó)�Ø�I‰I�aŽLñ ô 
��2‘˜˜dÓ	#€BÙ	ˆ!‹€AÙ	ˆ!‹€AÜ�1�q‘5Ž\ˆØˆa‰CˆØ‰TˆÜ�q˜!–ˆAØ�!˜‘E‘(˜2˜a™5‘.Ñ ŠBñ ä�B˜˜dÓ#ˆØ	ˆR‰ˆÜ�1˜!Ó"ˆßˆqÙñ ð 	
ˆA‰€AØ	ˆ!‰€AØƒuØ‰T‘!�A“$‰YˆÜ�q˜!–ˆAØ�1‰u˜‹zÙØ�!˜‘E‘(˜2˜a™5‘.Ñ ŠBñ ô �B˜˜dÓ#ˆØ	ˆR‰ˆØ€Hr6   c                 ó  • U R                   nUR                  R                  U5      n0 nS/UR                  -  nSXS'   [	        U5      nU  H3  nXc   (       d  M  [        Xe5      nUR                  X   Xc   -  5      XG'   M5     U" U5      $ )aƒ  
Return partial derivative of ``p`` with respect to ``x``.

Parameters
==========

x : :class:`~.PolyElement` with respect to which ``p`` is differentiated.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_diff
>>> R, x, y = ring('x, y', QQ)
>>> p = x + x**2*y**3
>>> rs_diff(p, x)
2*x*y**3 + 1
r   rM   )r   r?   r@   rl   rR   r   Ú
domain_new)r/   rA   r.   rT   r+   Úmnr|   rd   s           r4   Úrs_diffrÎ   Ý  s€   € ð( 	
�‰€AØ	�‰�‰�Q‹€AØ	€BØ
ˆˆQ�W‰W‰€BØ€B�EÜ	ˆr‹€BÛˆØ�7‰7Ü˜dÓ'ˆAØ—L‘L ¡¨©¡Ó1ˆB‹Eñ ñ ˆR‹5€Lr6   c                 ó  • U R                   n0 nUR                  R                  U5      nS/UR                  -  nSXT'   [	        U5      nU  H+  n[        Xe5      nUR                  X   Xd   S-   -  5      X7'   M-     U" U5      $ )a‚  
Integrate ``p`` with respect to ``x``.

Parameters
==========

x : :class:`~.PolyElement` with respect to which ``p`` is integrated.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_integrate
>>> R, x, y = ring('x, y', QQ)
>>> p = x + x**2*y**3
>>> rs_integrate(p, x)
1/3*x**3*y**3 + 1/2*x**2
r   rM   )r   r?   r@   rl   rR   r   rÌ   )r/   rA   r.   r+   rT   rÍ   r|   rd   s           r4   Úrs_integraterÐ   ý  s~   € ð( 	
�‰€AØ	€BØ	�‰�‰�Q‹€AØ
ˆˆQ�W‰W‰€BØ€B�EÜ	ˆr‹€BãˆÜ˜Ó"ˆØ—‘˜Q™W d¡g°¡kÑ2Ó3ˆ‹ñ ñ ˆR‹5€Lr6   c                 ó®  • U R                   n[        SUR                  5      u  pE[        US   5      nUSS XV4-   nUR                  nX€;   a  XPU   -   n	X U   -
  n
OUn	U n
[	        U[
        5      (       a  [        X‘5      " U6 nO	U" U	/UQ76 n[        UR                  5       5      nS/U-  nU H  nUS   XÞS   S   '   M     [        X­US   US   5      n
U
$ )a¯  
Function of a multivariate series computed by substitution.

The case with f method name is used to compute `rs\_tan` and `rs\_nth\_root`
of a multivariate series:

    `rs\_fun(p, tan, iv, prec)`

    tan series is first computed for a dummy variable _x,
    i.e, `rs\_tan(\_x, iv, prec)`. Then we substitute _x with p to get the
    desired series

Parameters
==========

p : :class:`~.PolyElement` The multivariate series to be expanded.
f : `ring\_series` function to be applied on `p`.
args[-2] : :class:`~.PolyElement` with respect to which, the series is to be expanded.
args[-1] : Required order of the expanded series.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_fun, _tan1
>>> R, x, y = ring('x, y', QQ)
>>> p = x + x*y + x**2*y + x**3*y**2
>>> rs_fun(p, _tan1, x, 4)
1/3*x**3*y**3 + 2*x**3*y**2 + x**3*y + 1/3*x**3 + x**2*y + x*y + x
Ú_xr¿   Néþÿÿÿr   rM   )
r   r©   rH   r—   rN   ÚstrÚgetattrr‡   r$   rÊ   )r/   rS   ÚargsÚ_RÚR1rÒ   ÚhÚargs1r”   Úx1r+   r]   r™   rœ   rA   s                  r4   Úrs_funrÜ     sê   € ð@ 
�‰€BÜ�$˜Ÿ	™	Ó"�F€BÜˆD�‰H‹€AØ��"ˆI˜˜Ñ€EØ	�‰€Bð 
ƒwØ�B‘%‰ZˆØ�2‘‰Y‰àˆØˆÜ�!”S×ÑÜ�BŒN˜EÐ"‰áˆbˆM�5ŠMˆÜˆq�w‰w‹yÓ€AØ	
ˆˆA‰€AÛˆØ�q‘TˆˆA‰$ˆq‰'‹
ñ ä	˜R D¨¡H¨d°2©hÓ	7€BØ€Ir6   c                 ó¨   • U R                   n0 nU R                  5        H)  u  pV[        U5      nXq==   U-  ss'   Xd[        U5      '   M+     U" U5      $ )z:
Return `p*x_i**n`.

`x\_i` is the ith variable in ``p``.
©r   r,   r#   rR   ©r/   rC   rT   r.   r]   rJ   r{   Úk1s           r4   r²   r²   U  sN   € ð 	
�‰€AØ
€AØ—‘–	‰ˆÜ�!‹WˆØ
‹�‰
‹ØŒ%�‹)‹ñ ñ ˆQ‹4€Kr6   c                 ó¨   • U R                   n0 nU R                  5        H)  u  pV[        U5      nXq==   U-  ss'   Xd[        U5      '   M+     U" U5      $ )a$  
>>> from sympy.polys.domains import QQ
>>> from sympy.polys.puiseux import puiseux_ring
>>> from sympy.polys.ring_series import pow_xin
>>> R, x, y = puiseux_ring('x, y', QQ)
>>> p = x**QQ(2,5) + x + x**QQ(2,3)
>>> index = p.ring.gens.index(x)
>>> pow_xin(p, index, 15)
x**6 + x**10 + x**15
rÞ   rß   s           r4   rQ   rQ   c  sN   € ð 	
�‰€AØ
€AØ—‘–	‰ˆÜ�!‹WˆØ
‹�‰
‹ØŒ%�‹)‹ñ ñ ˆQ‹4€Kr6   c                 óÂ  • [        X5      (       a  [        [        XX#5      $ U R                  nUR                  nXP;  a  [        S5      e[        U5      nX   S:X  d   eU" S5      nU S:X  a  U $ US:X  a  U" S5      $ US:X  a  U $ US:  a  U* nSnOSn[        U5       H*  n[        XaS-   X(5      n	[        X�X(5      n	XfU-  X‘-  -
  -  nM,     U(       a  U$ [        XbU5      $ )zS
Univariate series expansion of the nth root of ``p``.

The Newton method is used.
r§   rM   r   )rK   r^   Ú
_nth_root1r   r—   r³   r    r=   r‚   rs   r¨   )
r/   rT   rA   rB   r.   r”   r+   Úsignr¬   Útmps
             r4   rã   rã   v  sõ   € ô �Q×ÑÜœ: q¨QÓ5Ð5Ø	�‰€AØ	
�‰€BØ	ƒ{Ü!Ð">Ó?Ð?Üˆq‹	€AØ‰5�A‹:Ðˆ:Ù	
ˆ1‹€BØˆAƒvØˆØˆAƒvÙ�‹tˆØˆAƒvØˆØˆ1ƒuØˆBˆØ‰àˆÜ˜dÖ#ˆÜ�R˜Q™ Ó)ˆÜ�S˜QÓ&ˆØ
�‰d�S‘U‰lÑŠñ $ö Øˆ	ä! "¨Ó.Ð.r6   c                 óâ  ^• US:X  a"  U S:X  a  [        S5      eU R                  S5      $ US:X  a  [        XU5      $ U R                  nUR                  R	                  U5      m[        U U4S jS9T   n[        U TU* 5      n X5-  n[        U S-
  U5      (       au  UR                  nX   n[        U[        5      (       a'   UR                  5       nU" U[        SU5      -  5      n	O U" U[        SU5      -  5      n	[        X-  XU5      U	-  n
O[!        XX#5      n
U(       a  [        U5      U-  n[        U
TU5      n
U
$ ! [          a    [        S5      ef = f! [          a    [        S5      ef = f)aŸ  
Multivariate series expansion of the nth root of ``p``.

Parameters
==========

p : Expr
    The polynomial to computer the root of.
n : integer
    The order of the root to be computed.
x : :class:`~.PolyElement`
prec : integer
    Order of the expanded series.

Notes
=====

The result of this function is dependent on the ring over which the
polynomial has been defined. If the answer involves a root of a constant,
make sure that the polynomial is over a real field. It cannot yet handle
roots of symbols.

Examples
========

>>> from sympy.polys.domains import QQ, RR
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_nth_root
>>> R, x, y = ring('x, y', QQ)
>>> rs_nth_root(1 + x + x*y, -3, x, 3)
2/9*x**2*y**2 + 4/9*x**2*y + 2/9*x**2 - 1/3*x*y - 1/3*x + 1
>>> R, x, y = ring('x, y', RR)
>>> rs_nth_root(3 + x + x*y, 3, x, 2)
0.160249952256379*x*y + 0.160249952256379*x + 1.44224957030741
r   z0**0 expressionrM   c                 ó   >• U T   $ r‘   rb   r    s    €r4   rf   Úrs_nth_root.<locals>.<lambda>Æ  r¢   r6   rh   ú3The given series cannot be expanded in this domain.)rI   r   rE   r?   r@   r£   r²   rš   r—   rN   r   Úas_exprr   r	   r   r�   rã   )r/   rT   rA   rB   r.   rz   r”   rœ   Úc_exprÚconstr<   r@   s              @r4   r�   r�   ™  s}  ø€ ðH 	ˆAƒvØ�‹6ÜÐ.Ó/Ð/à—6‘6˜!“9ÐØˆAƒvÜ˜˜dÓ#Ð#Ø	�‰€AØ�F‰F�L‰L˜‹O€EÜˆAÔ%Ñ& uÑ-€AÜ��5˜1˜"Ó€AØ�I€Dä˜!˜a™% ×#Ñ#Ø�\‰\ˆØ‰EˆÜ�aœ×%Ñ%ð$ØŸ™›�Ù˜&¤2 a¨£8Ñ,Ó-‘ð
$Ù˜!œX a¨›^Ñ+Ó,�ô ˜!™#˜q TÓ*¨5Ñ0‰ä˜˜qÓ'ˆÞÜˆq‹E�A‰IˆÜ�c˜5 !Ó$ˆØ€Jøô ó $Ü!ð ##ó $ð $ð$ûô ó $Ü!ð ##ó $ð $ð$ús   Ã %D? Ã'E Ä?EÅE.c                 óV  • [        X5      (       a  [        [        XU5      $ U R                  nU S:X  a  UR                  $ [        X5      nU(       ad  SnUS:X  a    UR                  5       nU" [        U5      5      nU R                  U5      n[        U[        XU5      XS-
  5      n[        Xq5      U-   $ [        e! [         ab    UR                  [        W5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      n Nªf = f)aÒ  
The Logarithm of ``p`` modulo ``O(x**prec)``.

Notes
=====

Truncation of ``integral dx p**-1*d p/dx`` is used.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.puiseux import puiseux_ring
>>> from sympy.polys.ring_series import rs_log
>>> R, x = puiseux_ring('x', QQ)
>>> rs_log(1 + x, x, 8)
x + -1/2*x**2 + 1/3*x**3 + -1/4*x**4 + 1/5*x**5 + -1/6*x**6 + 1/7*x**7
>>> rs_log(x**QQ(3, 2) + 1, x, 5)
x**(3/2) + -1/2*x**3 + 1/3*x**(9/2)
rM   r   )rK   r[   Úrs_logr   r'   r�   rê   r   rI   Úadd_gensÚset_ringÚdiffrs   r¨   rÐ   r³   )r/   rA   rB   r.   rœ   rì   rë   Údlogs           r4   rî   rî   â  s  € ô* �Q×ÑÜœ& !¨Ó-Ð-Ø	�‰€AØˆAƒvØ�v‰vˆÜ˜1Ó €AÞØˆØ�‹6Øð	#Ø—Y‘Y“[ˆFÙ”c˜&“k“NˆEð �v‰v�a‹yˆÜ�dÔ.¨q°TÓ:¸AÀa¹xÓHˆÜ˜DÓ$ uÑ,Ð,ä!Ð!øô ó 	#Ø—
‘
œC ›K˜=Ó)ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”c˜&“k“NŠEð	#ús   Á!B< Â<A)D(Ä'D(c                 ó€  • [        X5      (       a  [        [        XU5      $ U R                  nU" S5      n[	        X5      (       a  [        S5      eXR                  ;   aZ  [        U5       HI  n[        XAU5      n[        XdX5      U -
  n[        XdS-   X5      n[        X�U5      n[        XxX5      n	XI-  nMK     U$ [
        e)ak  
Calculate the series expansion of the principal branch of the Lambert W
function.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_LambertW
>>> R, x, y = ring('x, y', QQ)
>>> rs_LambertW(x + x*y, x, 3)
-x**2*y**2 - 2*x**2*y - x**2 + x*y + x

See Also
========

LambertW
r   z>Polynomial must not have constant term in the series variablesrM   )rK   r[   Úrs_LambertWr   rš   r³   r?   r=   Úrs_exprs   rƒ   )
r/   rA   rB   r.   r+   r¬   rd   rn   Úp3rå   s
             r4   rô   rô     s¾   € ô( �Q×ÑÜœ+ q¨TÓ2Ð2Ø	�‰€AÙ	
ˆ1‹€BÜ˜!×ÑÜ!ð #9ó :ð 	:à�F‰Fƒ{Ü! $Ö'ˆEÜ�r˜eÓ$ˆAÜ˜˜qÓ(¨1Ñ,ˆBÜ˜ ™6 1Ó,ˆBÜ$ R¨EÓ2ˆBÜ˜ Ó*ˆCØ‰IŠBñ (ð ˆ	ä!Ð!r6   c                 ó�   • U R                   nU" S5      n[        U5       H"  nU [        XAU5      -
  n[        XdX5      nXG-  nM$     U$ )zHelper function for `rs\_exp`. rM   )r   r=   rî   rs   )r/   rA   rB   r.   r+   r¬   Úptrå   s           r4   Ú_exp1rù   8  sN   € à	�‰€AÙ	
ˆ1‹€BÜ˜dÖ#ˆØ”˜˜uÓ%Ñ%ˆÜ�R˜QÓ&ˆØ
‰	Šñ $ð €Ir6   c                 óŽ  • [        X5      (       a  [        [        XU5      $ U R                  n[	        X5      nU(       a5   UR                  5       nU" [        U5      5      nX-
  nU[        XqU5      -  $ [        U 5      S:”  a  [        XU5      $ U" S5      nSn	/ n[        U5       H  n
UR                  X‰-  5        U
S-  n
Xš-  n	M!     [        XX5      nU$ ! [         ab    UR                  [        W5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      n Náf = f)a  
Exponentiation of a series modulo ``O(x**prec)``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_exp
>>> R, x = ring('x', QQ)
>>> rs_exp(x**2, x, 7)
1/6*x**6 + 1/2*x**4 + x**2 + 1
r¾   rM   )rK   r[   rõ   r   r�   rê   r   rI   rï   rð   rx   rù   rw   rÁ   rÊ   )r/   rA   rB   r.   rœ   rë   rì   r+   r«   rT   rJ   rX   s               r4   rõ   rõ   B  s0  € ô �Q×ÑÜœ& !¨Ó-Ð-Ø	�‰€AÜ˜1Ó €AÞð	#Ø—Y‘Y“[ˆFÙ”c˜&“k“NˆEð ‰Uˆð ”V˜B 4Ó(Ñ(Ð(ä
ˆ1ƒv�ƒ{Ü�Q˜4Ó Ð Ù
ˆA‹$€CØ	€AØ
€AÜ�4Ž[ˆØ	�‰�‘ŒØ	ˆQ‰ˆØ	‰Šñ ô
 	˜A !Ó*€AØ€Høô1 ó 	#Ø—
‘
œC ›K˜=Ó)ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”c˜&“k“NŠEð	#ús   Á!C ÃA)EÅEc                 óÜ   • U R                   nU" S5      nU* /n[        XU5      n[        SU5       H  nUR                  XG-  SU-  S-   -  5        M!     [	        XeX5      n[        X€X5      nU$ )zG
Expansion using formula.

Faster on very small and univariate series.
r¿   rM   r8   ©r   r~   rw   rÁ   rÊ   rs   )	r/   re   rB   r.   Úmorœ   rn   rJ   rÃ   s	            r4   Ú_atanrþ   r  sr   € ð 	
�‰€AÙ	
ˆ2‹€BØ
ˆˆ€AÜ	�1˜$Ó	€BÜ�1�dŽ^ˆØ	�‰�‘˜˜!™˜a™‘Ö!ñ ä˜B 2Ó,€AÜˆq�RÓ€AØ€Hr6   c                 óJ  • [        X5      (       a  [        [        XU5      $ U R                  nSn[	        X5      nU(       a"   UR                  5       nU" [        U5      5      nU R                  U5      n[        XU5      U" S5      -   n[        X�US-
  5      n[        XxXS-
  5      n[        X�5      U-   $ ! [         ab    UR                  [        W5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      n N½f = f)av  
The arctangent of a series

Return the series expansion of the atan of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_atan
>>> R, x, y = ring('x, y', QQ)
>>> rs_atan(x + x*y, x, 4)
-1/3*x**3*y**3 - x**3*y**2 - x**3*y - 1/3*x**3 + x*y + x

See Also
========

atan
r   rM   )rK   r[   Úrs_atanr   r�   rê   r   rI   rï   rð   rñ   r~   rƒ   rs   rÐ   ©	r/   rA   rB   r.   rì   rœ   rë   Údpr+   s	            r4   r   r   ‚  s  € ô* �Q×ÑÜœ' 1¨Ó.Ð.Ø	�‰€AØ€EÜ˜1Ó €AÞð	$Ø—Y‘Y“[ˆFÙ”d˜6“l“OˆEð 
�‰�‹€BÜ	�1˜Ó	¡ 1£Ñ	%€BÜ	˜R D¨1¡HÓ	-€BÜ	�˜ !™8Ó	$€BÜ˜Ó Ñ&Ð&øô ó 	$Ø—
‘
œD ›L˜>Ó*ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”d˜6“l“OŠEð	$ús   Á!B6 Â6A)D"Ä!D"c                 ó.  • [        X5      (       a  [        [        XU5      $ [        X5      (       a  [	        S5      eU R
                  nXR                  ;   a¹  [        U 5      S:”  aG  [        X5      nS[        XUS-
  5      -
  n[        USXS-
  5      n[        XEXS-
  5      n[        XQ5      $ U" S5      nSUS/n[        SUS5       H9  nUR                  US-
  S-  US   -  XˆS-
  -  -  5        UR                  S5        M;     [        XX5      $ [        e)aV  
Arcsine of a series

Return the series expansion of the asin of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_asin
>>> R, x, y = ring('x, y', QQ)
>>> rs_asin(x, x, 8)
5/112*x**7 + 3/40*x**5 + 1/6*x**3 + x

See Also
========

asin
z:Polynomial must not have constant term in series variablesr¾   rM   rÓ   r   r€   r8   )rK   r[   Úrs_asinrš   r³   r   r?   rx   rÎ   r~   r�   rs   rÐ   rw   rÁ   rÊ   )	r/   rA   rB   r.   r  r+   r«   rœ   rJ   s	            r4   r  r  °  s  € ô* �Q×ÑÜœ' 1¨Ó.Ð.Ü˜!×ÑÜ!ð #7ó 8ð 	8à	�‰€AØ�F‰Fƒ{äˆq‹6�B‹;Ü˜“ˆBØ”Y˜q T¨A¡XÓ.Ñ.ˆBÜ˜R  Q¨q©Ó1ˆBÜ˜ ¨!¡8Ó,ˆBÜ Ó&Ð&Ù�‹dˆØ��QˆKˆÜ�q˜$ Ö"ˆAØ�H‰H�a˜!‘e˜a‘Z  "¡Ñ% q¨a©%¡yÑ1Ô2Ø�H‰H�QŽKñ #ô # 1¨Ó1Ð1ô "Ð!r6   c           
      ó¬   • U R                   nU" S5      n[        U5       H0  nU [        XAU5      -
  n[        US[	        XAU5      -   X5      nXF-  nM2     U$ )ak  
Helper function of :func:`rs_tan`.

Return the series expansion of tan of a univariate series using Newton's
method. It takes advantage of the fact that series expansion of atan is
easier than that of tan.

Consider `f(x) = y - \arctan(x)`
Let r be a root of f(x) found using Newton's method.
Then `f(r) = 0`
Or `y = \arctan(x)` where `x = \tan(y)` as required.
r   rM   )r   r=   r   rs   r~   ©r/   rA   rB   r.   r+   r¬   rå   s          r4   Ú_tan1r  Ý  s^   € ð 	
�‰€AÙ	
ˆ1‹€BÜ˜dÖ#ˆØ”'˜" Ó'Ñ'ˆÜ�S˜!œi¨¨uÓ5Ñ5°qÓ@ˆØ
‰	Šñ $ð €Ir6   c                 ód  • [        X5      (       a  [        [        XU5      nU$ U R                  nSn[	        X5      nU(       aR   UR                  5       nU" [        U5      5      nX-
  n[        X�U5      n	[        SXY-  -
  X5      n
[        XY-   X¡U5      $ UR                  S:X  a  [        XU5      $ [        U [        X5      $ ! [         ab    UR                  [        W5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      n NÈf = f)a|  
 Tangent of a series.

 Return the series expansion of the tan of ``p``, about 0.

 Examples
 ========

 >>> from sympy.polys.domains import QQ
 >>> from sympy.polys.rings import ring
 >>> from sympy.polys.ring_series import rs_tan
 >>> R, x, y = ring('x, y', QQ)
 >>> rs_tan(x + x*y, x, 4)
 1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x

See Also
========

_tan1, tan
r   rM   )rK   r[   Úrs_tanr   r�   rê   r   rI   rï   rð   rƒ   rs   rl   r  rÜ   )r/   rA   rB   rX   r.   rì   rœ   rë   r+   Út2r­   s              r4   r	  r	  ò  s  € ô* �Q×ÑÜ”v˜q TÓ*ˆØˆØ	�‰€AØ€EÜ˜1Ó €AÞð	#Ø—Y‘Y“[ˆFÙ”c˜&“k“NˆEð ‰Uˆô �B˜4Ó ˆÜ  E¡H¡¨aÓ6ˆÜ�e‘j !¨Ó-Ð-à‡w�w�!ƒ|Ü�Q˜4Ó Ð ä�aœ Ó)Ð)øô% ó 	#Ø—
‘
œC ›M˜?Ó+ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”c˜&“k“NŠEð	#ús   Á!C ÃA)D/Ä.D/c                 ó"  • [        X5      (       a  [        [        XU5      nU$ [        XS5      u  pE[	        USU-  -   5      n[        XU5      u  px[        X„U* 5      n[        X�U5      n[        XxX5      n	[        X”U* 5      n	[        X‘U5      n	U	$ )aX  
Cotangent of a series

Return the series expansion of the cot of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cot
>>> R, x, y = ring('x, y', QQ)
>>> rs_cot(x, x, 6)
-2/945*x**5 - 1/45*x**3 - 1/3*x + x**(-1)

See Also
========

cot
Úcotr8   )
rK   r[   Úrs_cotr¥   rH   Ú
rs_cos_sinr²   rƒ   rs   rE   )
r/   rA   rB   rX   rC   rz   Úprec1rœ   rÃ   r<   s
             r4   r  r  %  s”   € ô. �Q×ÑÜ”v˜q TÓ*ˆØˆÜ˜Q 5Ó)�D€AÜ��q˜‘s‘
‹O€EÜ�a˜EÓ"�D€AÜ��q�bÓ€AÜ˜A %Ó(€AÜ
��qÓ
 €CÜ
�#˜1˜"Ó
€CÜ
�3˜4Ó
 €CØ€Jr6   c                 ó¼  • [        X5      (       a  [        [        XU5      $ UR                  nU (       d  U" S5      $ [	        X5      nU(       aM   UR                  5       nU" [        U5      5      U" [        U5      5      pvX-
  n[        X�U5      u  pšX§-  X–-  -   $ [        U 5      S:”  aJ  UR                  S:X  a:  [        U S-  X5      n[        X±U5      n[!        SU-   X5      n[#        USU-  X5      $ U" S5      nSnS/n[%        SUS-   S5       H2  nUR'                  XÍ-  5        UR'                  S5        XÞ* US-   -  -  nM4     [)        XX5      $ ! [         a}    UR                  [        W5      [        U5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      U" [        U5      5      pv GNYf = f)aù  
Sine of a series

Return the series expansion of the sin of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.puiseux import puiseux_ring
>>> from sympy.polys.ring_series import rs_sin
>>> R, x, y = puiseux_ring('x, y', QQ)
>>> rs_sin(x + x*y, x, 4)
x + x*y + -1/6*x**3 + -1/2*x**3*y + -1/2*x**3*y**2 + -1/6*x**3*y**3
>>> rs_sin(x**QQ(3, 2) + x*y**QQ(7, 5), x, 4)
x*y**(7/5) + x**(3/2) + -1/6*x**3*y**(21/5) + -1/2*x**(7/2)*y**(14/5)

See Also
========

sin
r   r¾   rM   r8   )rK   r[   Úrs_sinr   r�   rê   r   r   rI   rï   rð   r  rx   rl   r	  r~   rƒ   rs   rw   rÁ   rÊ   ©r/   rA   rB   r.   rœ   rë   Út1r
  r+   Úp_cosÚp_sinr­   r«   rT   rJ   s                  r4   r  r  I  s³  € ô. �Q×ÑÜœ& !¨Ó-Ð-Ø	�‰€AÞÙ�‹tˆÜ˜1Ó €AÞð	4Ø—Y‘Y“[ˆFÙ”s˜6“{“^¡Q¤s¨6£{£^�ð ‰Uˆô " "¨Ó.‰ˆØ‰x˜%™(Ñ"Ð"ô ˆ1ƒv�ƒ{�q—w‘w !“|Ü�1�Q‘3˜Ó ˆÜ�q˜TÓ"ˆÜ   R¡¨Ó1ˆÜ�b˜!˜A™#˜qÓ'Ð'Ù
ˆA‹$€CØ	€AØ	
ˆ€AÜ�1�d˜Q‘h Ö"ˆØ	�‰�‘ŒØ	�‰�ŒØ	ˆR��Q‘‰Z‰Šñ #ô ˜q QÓ-Ð-øô7 ó 	4Ø—
‘
œC ›K¬¨V«Ð5Ó6ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”s˜6“{“^¡Q¤s¨6£{£^“ð	4ús   Á1E ÅBGÇGc                 óœ  • [        X5      (       a  [        [        XU5      $ U R                  n[	        X5      nU(       aM   UR                  5       nU" [        U5      5      U" [        U5      5      pvX-
  n[        X�U5      u  pšX—-  X¦-  -
  $ [        U 5      S:”  aJ  UR                  S:X  a:  [        U S-  X5      n[        X±U5      n[!        SU-   X5      n[#        USU-
  X5      $ U" S5      nSn/ n[%        SUS-   S5       H2  nUR'                  XÍ-  5        UR'                  S5        XÞ* US-
  -  -  nM4     [)        XX5      $ ! [         a}    UR                  [        W5      [        U5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      U" [        U5      5      pv GNXf = f)aÓ  
Cosine of a series

Return the series expansion of the cos of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.puiseux import puiseux_ring
>>> from sympy.polys.ring_series import rs_cos
>>> R, x, y = puiseux_ring('x, y', QQ)
>>> rs_cos(x + x*y, x, 4)
1 + -1/2*x**2 + -1*x**2*y + -1/2*x**2*y**2
>>> rs_cos(x + x*y, x, 4)/x**QQ(7, 5)
x**(-7/5) + -1/2*x**(3/5) + -1*x**(3/5)*y + -1/2*x**(3/5)*y**2

See Also
========

cos
r¾   rM   r8   r   )rK   r[   Úrs_cosr   r�   rê   r   r   rI   rï   rð   r  rx   rl   r	  r~   rƒ   rs   rw   rÁ   rÊ   r  s                  r4   r  r  ‡  s¥  € ô. �Q×ÑÜœ& !¨Ó-Ð-Ø	�‰€AÜ˜1Ó €AÞð	4Ø—Y‘Y“[ˆFÙ”s˜6“{“^¡Q¤s¨6£{£^�ð ‰Uˆô " "¨Ó.‰ˆØ‰x˜%™(Ñ"Ð"ô ˆ1ƒv�ƒ{�q—w‘w !“|Ü�1�Q‘3˜Ó ˆÜ�q˜TÓ"ˆÜ   2¡ qÓ/ˆÜ�b˜!˜b™& !Ó*Ð*Ù
ˆA‹$€CØ	€AØ
€AÜ�1�d˜Q‘h Ö"ˆØ	�‰�‘ŒØ	�‰�ŒØ	ˆR��Q‘‰Z‰Šñ #ô ˜q QÓ-Ð-øô5 ó 	4Ø—
‘
œC ›K¬¨V«Ð5Ó6ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”s˜6“{“^¡Q¤s¨6£{£^“ð	4ús   Á1E ÅBGÇ
Gc                 ó6  • [        X5      (       a  [        [        XU5      $ U R                  nU (       d  U" S5      U" S5      4$ [	        X5      nU(       aV   UR                  5       nU" [        U5      5      U" [        U5      5      pvX-
  n[        X�U5      u  pšX—-  X¦-  -
  X–-  X§-  -   4$ [        U 5      S:”  aZ  UR                  S:X  aJ  [        U S-  X5      n[        X±U5      n[        SU-   X5      n[!        USU-
  X5      [!        USU-  X5      4$ U" S5      n/ nSu  pï[#        SUS-   S5       H5  nUR%                  XÎ-  S4SXÏ-  4/5        U* U-  US-
  -  U* U-  US-   -  pþM7     ['        U6 u  nn[)        XX5      [)        U UX5      4$ ! [         a}    UR                  [        W5      [        U5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      U" [        U5      5      pv GNŽf = f)aÔ  
Cosine and sine of a series

Return the series expansion of the cosine and sine of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cos_sin
>>> R, x, y = ring('x, y', QQ)
>>> c, s = rs_cos_sin(x + x*y, x, 4)
>>> c
-1/2*x**2*y**2 - x**2*y - 1/2*x**2 + 1
>>> s
-1/6*x**3*y**3 - 1/2*x**3*y**2 - 1/2*x**3*y - 1/6*x**3 + x*y + x

See Also
========

rs_cos, rs_sin
r   r¾   rM   r8   )rM   rM   )rK   r[   r  r   r�   rê   r   r   rI   rï   rð   rx   rl   r	  r~   rƒ   rs   rw   Úextendr*   rÊ   )r/   rA   rB   r.   rœ   rë   r  r
  r+   r  r  r­   r«   ÚcoeffsÚcnÚsnrJ   rÃ   s                     r4   r  r  Â  s  € ô0 �Q×ÑÜœ* a¨DÓ1Ð1Ø	�‰€AÞÙ�‹t‘Q�q“TˆzÐÜ˜1Ó €AÞð	4Ø—Y‘Y“[ˆFÙ”s˜6“{“^¡Q¤s¨6£{£^�ð ‰UˆÜ! "¨Ó.‰ˆØ‰x˜%™(Ñ" E¡H¨u©xÑ$7Ð7Ð7ä
ˆ1ƒv�ƒ{�q—w‘w !“|Ü�1�Q‘3˜Ó ˆÜ�q˜TÓ"ˆÜ   R¡¨Ó1ˆÜ�r˜1˜r™6 1Ó+¬V°B¸¸!¹¸QÓ-EÐFÐFá
ˆA‹$€CØ€FØ�F€BÜ�1�d˜1‘f˜aÖ ˆØ�‰˜™ �{ Q¨© KÐ0Ô1Ø��Q‘˜˜A™‘   A¡ q¨1¡u¡ŠBñ !ô �ˆ<�D€A€qÜ  aÓ.Ô0CÀAÀqÈ!Ó0RÐSÐSøô3 ó 	4Ø—
‘
œC ›K¬¨V«Ð5Ó6ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”s˜6“{“^¡Q¤s¨6£{£^“ð	4ús   Á1F ÆBHÈHc                 óÖ   • U R                   nU" S5      nU/n[        XU5      n[        SU5       H  nUR                  USU-  S-   -  5        M     [	        XeX5      n[        X€X5      nU$ )zF
Expansion using formula

Faster for very small and univariate series
rM   r8   rü   )	r/   rA   rB   r.   r«   rœ   rn   rJ   rÃ   s	            r4   Ú_atanhr  ÿ  sn   € ð 	
�‰€AÙ
ˆA‹$€CØ	ˆ€AÜ	�1˜Ó	€BÜ�1�dŽ^ˆØ	�‰��a˜‘c˜A‘g‘Öñ ä˜B 1Ó+€AÜˆq�QÓ€AØ€Hr6   c                 óˆ  • [        X5      (       a  [        [        XU5      $ U R                  nSn[	        X5      nU(       a"   UR                  5       nU" [        U5      5      n[        X5      n[        XU5      * S-   n[        X�US-
  5      n[        XxXS-
  5      n[        X�5      U-   $ ! [         a    [        S5      ef = f)a€  
Hyperbolic arctangent of a series

Return the series expansion of the atanh of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_atanh
>>> R, x, y = ring('x, y', QQ)
>>> rs_atanh(x + x*y, x, 4)
1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x

See Also
========

atanh
r   ré   rM   )rK   r[   Úrs_atanhr   r�   rê   r   rI   r	   rÎ   r~   rƒ   rs   rÐ   r  s	            r4   r   r     sÉ   € ô* �Q×ÑÜœ( A¨$Ó/Ð/Ø	�‰€AØ€EÜ˜1Ó €AÞð	 Ø—Y‘Y“[ˆFÙ”e˜F“mÓ$ˆEô 
�‹€BÜ�Q˜4Ó Ð	  1Ñ	$€BÜ	˜R D¨1¡HÓ	-€BÜ	�˜ !™8Ó	$€BÜ˜Ó Ñ&Ð&øô ó 	 Üð ó  ð  ð	 ús   Á!B+ Â+Cc                 ó–  • [        X5      (       a  [        [        XU5      $ U R                  nSn[	        X5      nU(       a"   UR                  5       nU" [        U5      5      n[        X5      n[        XU5      nXƒ" S5      -   n	[        U	SXS-
  5      n
[        XzXS-
  5      n
[        X¡5      U-   $ ! [         a    [        S5      ef = f)ab  
Hyperbolic arcsine of a series

Return the series expansion of the arcsinh of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_asinh
>>> R, x = ring('x', QQ)
>>> rs_asinh(x, x, 9)
-5/112*x**7 + 3/40*x**5 - 1/6*x**3 + x

See Also
========

asinh
r   ré   rM   rÓ   )rK   r[   Úrs_asinhr   r�   rê   r   rI   r	   rÎ   r~   r�   rs   rÐ   )r/   rA   rB   r.   rì   rœ   rë   r  Ú	p_squaredÚdenomr+   s              r4   r"  r"  :  sÑ   € ô* �Q×ÑÜœ( A¨$Ó/Ð/Ø	�‰€AØ€EÜ˜1Ó €AÞð	 Ø—Y‘Y“[ˆFÙ”e˜F“mÓ$ˆEô 
�‹€BÜ˜! Ó%€IØ˜˜!›Ñ€EÜ	�U˜B ¨!¡8Ó	,€BÜ	�˜ !™8Ó	$€BÜ˜Ó Ñ&Ð&øô ó 	 Üð ó  ð  ð	 ús   Á!B2 Â2Cc                 óˆ  • [        X5      (       a  [        [        XU5      $ U R                  nU (       d  U" S5      $ [	        X5      nU(       aM   UR                  5       nU" [        U5      5      U" [        U5      5      pvX-
  n[        X�U5      u  pšX§-  X–-  -   $ [        XU5      n[        X±U5      nX¶-
  S-  $ ! [         a|    UR                  [        W5      [        U5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      U" [        U5      5      pv N¿f = f)a~  
Hyperbolic sine of a series

Return the series expansion of the sinh of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_sinh
>>> R, x, y = ring('x, y', QQ)
>>> rs_sinh(x + x*y, x, 4)
1/6*x**3*y**3 + 1/2*x**3*y**2 + 1/2*x**3*y + 1/6*x**3 + x*y + x

See Also
========

sinh
r   r8   )rK   r[   Úrs_sinhr   r�   rê   r   r   rI   rï   rð   Úrs_cosh_sinhrõ   rƒ   ©r/   rA   rB   r.   rœ   rë   r  r
  r+   Úp_coshÚp_sinhr­   s               r4   r&  r&  f  ó  € ô* �Q×ÑÜœ' 1¨Ó.Ð.Ø	�‰€AÞÙ�‹tˆÜ˜1Ó €AÞð	6Ø—Y‘Y“[ˆFÙ”t˜F“|“_¡a¬¨V«£o�ð ‰UˆÜ% b¨TÓ2‰ˆØ‰{˜V™[Ñ(Ð(äˆq�TÓ€AÜ	˜Q 4Ó	(€BØ‰F�A‰:Ðøô ó 	6Ø—
‘
œD ›L¬$¨v«,Ð7Ó8ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”t˜F“|“_¡a¬¨V«£o’ð	6úó   Á1B; Â;BEÅ Ec                 óˆ  • [        X5      (       a  [        [        XU5      $ U R                  nU (       d  U" S5      $ [	        X5      nU(       aM   UR                  5       nU" [        U5      5      U" [        U5      5      pvX-
  n[        X�U5      u  pšX—-  X¦-  -   $ [        XU5      n[        X±U5      nX¶-   S-  $ ! [         a|    UR                  [        W5      [        U5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      U" [        U5      5      pv N¿f = f)af  
Hyperbolic cosine of a series

Return the series expansion of the cosh of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cosh
>>> R, x, y = ring('x, y', QQ)
>>> rs_cosh(x + x*y, x, 4)
1/2*x**2*y**2 + x**2*y + 1/2*x**2 + 1

See Also
========

cosh
r   r8   )rK   r[   Úrs_coshr   r�   rê   r   r   rI   rï   rð   r'  rõ   rƒ   r(  s               r4   r.  r.  ”  r+  r,  c                 ó¸  • [        X5      (       a  [        [        XU5      $ U R                  nU (       d  U" S5      U" S5      4$ [	        X5      nU(       aV   UR                  5       nU" [        U5      5      U" [        U5      5      pvX-
  n[        X�U5      u  pšX—-  X¦-  -   X§-  X–-  -   4$ [        XU5      n[        X±U5      nX¶-   S-  X¶-
  S-  4$ ! [         a|    UR                  [        W5      [        U5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      U" [        U5      5      pv NÏf = f)aî  
Hyperbolic cosine and sine of a series

Return the series expansion of the hyperbolic cosine and sine of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_cosh_sinh
>>> R, x, y = ring('x, y', QQ)
>>> c, s = rs_cosh_sinh(x + x*y, x, 4)
>>> c
1/2*x**2*y**2 + x**2*y + 1/2*x**2 + 1
>>> s
1/6*x**3*y**3 + 1/2*x**3*y**2 + 1/2*x**3*y + 1/6*x**3 + x*y + x

See Also
========

rs_cosh, rs_sinh
r   r8   )rK   r[   r'  r   r�   rê   r   r   rI   rï   rð   rõ   rƒ   r(  s               r4   r'  r'  Â  s=  € ô0 �Q×ÑÜœ,¨¨dÓ3Ð3Ø	�‰€AÞÙ�‹t‘Q�q“TˆzÐÜ˜1Ó €AÞð	6Ø—Y‘Y“[ˆFÙ”t˜F“|“_¡a¬¨V«£o�ð ‰UˆÜ% b¨TÓ2‰ˆØ‰{˜V™[Ñ(¨&©+¸¹Ñ*CÐCÐCäˆq�TÓ€AÜ	˜Q 4Ó	(€BØ‰F�A‰:˜™ ‘zÐ!Ð!øô ó 	6Ø—
‘
œD ›L¬$¨v«,Ð7Ó8ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”t˜F“|“_¡a¬¨V«£o’ð	6ús   Á1C ÃBEÅEc           
      ó¬   • U R                   nU" S5      n[        U5       H0  nU [        XAU5      -
  n[        US[	        XAU5      -
  X5      nXF-  nM2     U$ )zì
Helper function of :func:`rs_tanh`

Return the series expansion of tanh of a univariate series using Newton's
method. It takes advantage of the fact that series expansion of atanh is
easier than that of tanh.

See Also
========

_tanh
r   rM   )r   r=   r   rs   r~   r  s          r4   Ú_tanhr1  ô  s^   € ð 	
�‰€AÙ	
ˆ1‹€BÜ˜dÖ#ˆØ”(˜2 %Ó(Ñ(ˆÜ�S˜!œi¨¨tÓ4Ñ4°aÓ?ˆØ
‰	Šñ $ð €Ir6   c                 ó`  • [        X5      (       a  [        [        XU5      $ U R                  nSn[	        X5      nU(       aR   UR                  5       nU" [        U5      5      nX-
  n[        XqU5      n[        SXH-  -   X5      n	[        XH-   X‘U5      $ UR                  S:X  a  [        XU5      $ [        U [        X5      $ ! [         ab    UR                  [        W5      /5      nU R                  U5      n UR                  U5      nUR                  U5      nU" [        U5      5      n NÈf = f)az  
Hyperbolic tangent of a series

Return the series expansion of the tanh of ``p``, about 0.

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_tanh
>>> R, x, y = ring('x, y', QQ)
>>> rs_tanh(x + x*y, x, 4)
-1/3*x**3*y**3 - x**3*y**2 - x**3*y - 1/3*x**3 + x*y + x

See Also
========

tanh
r   rM   )rK   r[   Úrs_tanhr   r�   rê   r   rI   rï   rð   rƒ   rs   rl   r1  rÜ   )
r/   rA   rB   r.   rì   rœ   rë   r+   r  r­   s
             r4   r3  r3  	  s  € ô* �Q×ÑÜœ' 1¨Ó.Ð.Ø	�‰€AØ€EÜ˜1Ó €AÞð	$Ø—Y‘Y“[ˆFÙ”d˜6“l“OˆEð ‰UˆÜ�R˜DÓ!ˆÜ  E¡H¡¨aÓ6ˆÜ�e‘j !¨Ó-Ð-à‡w�w�!ƒ|Ü�Q˜4Ó Ð ä�aœ Ó(Ð(øô ó 	$Ø—
‘
œD ›L˜>Ó*ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAØ—
‘
˜1“ˆAÙ”d˜6“l“OŠEð	$ús   Á!C ÃA)D-Ä,D-c                 óš   • U R                  5       n[        U 5      n[        XAU5      n[        UR	                  U5      XQU5      nX6U-  -
  nU$ )a#  
Compute the truncated Newton sum of the polynomial ``p``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_newton
>>> R, x = ring('x', QQ)
>>> p = x**2 - 2
>>> rs_newton(p, x, 5)
8*x**4 + 4*x**2 + 2
)r&   r5   rƒ   rs   rñ   )r/   rA   rB   r-   r+   rn   rö   r<   s           r4   Ú	rs_newtonr5  8  sK   € ð �(‰(‹*€CÜ	˜Ó	€BÜ	˜R DÓ	)€BÜ	�—‘˜“
˜B 4Ó	(€BØ
�1‘‰*€CØ€Jr6   c                 óP  • U R                   nUR                  [        :w  a  [        eUR                  nU(       d7  U R                  5        H!  u  pEU[        [        US   5      5      -  X4'   M#     U$ U R                  5        H!  u  pEU[        [        US   5      5      -  X4'   M#     U$ )aˆ  
Return ``sum f_i/i!*x**i`` from ``sum f_i*x**i``,
where ``x`` is the first variable.

If ``inverse=True`` return ``sum f_i*i!*x**i``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_hadamard_exp
>>> R, x = ring('x', QQ)
>>> p = 1 + x + x**2 + x**3
>>> rs_hadamard_exp(p)
1/6*x**3 + 1/2*x**2 + x + 1
r   )r   r©   r   r³   r'   r$   rH   r   )r+   Úinverser.   r/   rD   rp   s         r4   Úrs_hadamard_expr8  N  sŽ   € ð$ 	�‰€AØ‡x�x”2ƒ~Ü!Ð!Ø	�‰€AÞØŸ™ž
‰HˆDØœœT $ q¡'›]Ó+Ñ+ˆA‹Gñ #ð
 €Hð Ÿ™ž
‰HˆDØœœT $ q¡'›]Ó+Ñ+ˆA‹Gñ #à€Hr6   c                 ó  • U R                   nUR                  S   nU R                  5       UR                  5       -  S-   n[        XU5      n[	        U5      n[        XU5      n[	        U5      n[        XhX45      n	[	        U	S5      n
U
S   U
-
  U-  n[        X³5      n[        XÃU5      n[        U5      nUR                  5       S   nU R                  5       UR                  5       -  UR                  5       -
  nU(       a  XÃU-  -  nU$ )a5  
compute the composed sum ``prod(p2(x - beta) for beta root of p1)``

Examples
========

>>> from sympy.polys.domains import QQ
>>> from sympy.polys.rings import ring
>>> from sympy.polys.ring_series import rs_compose_add
>>> R, x = ring('x', QQ)
>>> f = x**2 - 2
>>> g = x**2 - 3
>>> rs_compose_add(f, g)
x**4 - 10*x**2 + 1

References
==========

.. [1] A. Bostan, P. Flajolet, B. Salvy and E. Schost
       "Fast Computation with Two Algebraic Numbers",
       (2002) Research Report 4579, Institut
       National de Recherche en Informatique et en Automatique
r   rM   T)r   )
r   r?   r&   r5  r8  rs   rÐ   rõ   r5   Ú	primitive)r+   rn   r.   rA   rB   Únp1Únp1eÚnp2Únp2eÚnp3eÚnp3Únp3ar]   r  s                 r4   Úrs_compose_addrB  l  sñ   € ð0 	�‰€AØ	�‰ˆq‰	€AØ�9‰9‹;�r—y‘y“{Ñ" QÑ&€DÜ
�B˜4Ó
 €CÜ˜3Ó€DÜ
�B˜4Ó
 €CÜ˜3Ó€DÜ�$˜aÓ&€DÜ
˜$ Ó
%€CØ�‰I˜‰O˜qÑ €DÜ�TÓ€AÜˆq�TÓ€AÜ�qÓ€AØ	�‰‹�aÑ€AØ	�‰‹�R—Y‘Y“[Ñ	  1§8¡8£:Ñ	-€Bö 
Ø�‰e‰GˆØ€Hr6   r  r  rõ   r	  rî   r   r&  r.  r3  )	r   r   r   r   r   r   r   r   r   c                 óÊ   ^• SnSnUS:X  a  [        XX$5      nUS-  nUS:X  a  M  UR                  nU" U5      nUR                  R                  U5      m[	        UU4S jS9T   $ )z=Find the minimum power of `a` in the series expansion of exprr   r8   c                 ó   >• U T   $ r‘   rb   )r­   rC   s    €r4   rf   Úrs_min_pow.<locals>.<lambda>µ  s	   ø€  Q q¢Tr6   rh   )Ú
_rs_seriesr   r?   r@   r£   )ÚexprÚ	series_rsr™   ÚseriesrT   r.   rC   s         @r4   Ú
rs_min_powrJ  «  si   ø€ à€FØ	€AØ
�A‹+Ü˜D¨QÓ2ˆØ	ˆQ‰ˆð �A�+ð 	�‰€AÙ	ˆ!‹€AØ	�‰�‰�Q‹€AÜˆvœ>Ñ*¨1Ñ-Ð-r6   c                 ó\  • U R                   nUR                  n[        S U 5       5      (       d  U R                  (       d  U$ U R	                  U5      (       d  U$ U R                  (       a¨  US   n[        U5      S:”  a  [        e[        U[        SSS9u  px[        XhX#5      n	UR                  U5      R                  U	R                  5      nU	R                  U5      n	[        [        [        U R                  5         5      " U	U" U5      U5      nU$ U R                   (       Ga%  [        U5      n
U H4  nUR"                  (       a  M  [        USSS9u  p{UR                  U5      nM6     [%        ['        [(        XD Vs/ s H
  oe" U5      PM     snU/[        U5      -  5      5      n[+        U5      nU" S5      n[-        U
5       Hm  n[        XN   U" XN   5      U[/        UU-
  XÎ   -   5      5      nUR                  UR                  5      nUR                  U5      nUR                  U5      nX�-  nMo     [1        X…" U5      U5      nU$ U R2                  (       a  [        U5      n
U" S5      n[-        U
5       H[  n[        XN   U" XN   5      X#5      nUR                  UR                  5      nUR                  U5      nUR                  U5      nX�-  nM]     U$ U R4                  (       az  [        U R6                  [        SSS9u  p{UR                  U5      n[        U R6                  U" U R6                  5      X#5      n	[9        X�R:                  U	R                  U5      U5      $ [=        U [>        5      (       a(  U RA                  5       (       a  [        U [        SSS9S   $ [        es  snf )Nc              3   óJ   #   • U  H  oR                  [        5      v •  M     g 7fr‘   )Úhasr   )r’   Úargs     r4   r•   Ú_rs_series.<locals>.<genexpr>¿  s   é € Ð1ªD S�w‰w”x× Ð ªDùs   ‚!#r   rM   FT©r©   ÚexpandrI  )rQ  rI  )!rÖ   r   r˜   Úis_FunctionrM  rx   r³   r   r   rF  Úcomposerð   ÚevalÚ_convert_funcrÔ   ÚfuncÚis_MulÚ	is_Numberr#   ÚmaprJ  Úsumrw   r   rE   Úis_AddÚis_PowÚbaser‚   r   rN   r   Úis_constant)rG  rH  r™   rB   rÖ   r.   rN  rØ   rI  Úseries_innerrT   Ú_Úmin_powsÚsum_powsrC   Ú_seriess                   r4   rF  rF  ¸  s(  € ð �9‰9€DØ�‰€Aô Ñ1©DÓ1×1Ñ1¸$×:J×:JØÐà�8‰8�A�;‰;ØÐà	×	×	Ø�1‰gˆÜˆt‹9�q‹=Ü%Ð%Ü˜3¤r°%ÀÑE‰
ˆÜ! #¨qÓ7ˆð �I‰I�b‹M×!Ñ! ,×"3Ñ"3Ó4ˆØ#×,Ñ,¨QÓ/ˆÜ”m¤C¨¯	©	£NÑ3Ô4°\Ùˆa‹D�$óˆàˆà	��ˆÜ�‹IˆÛˆCØ—=—=‘=Ü˜c¨%¸Ñ=‘�Ø—I‘I˜b“M’ñ ô œœJ¨ÀÓ.FÂ¸#¨q°®vÁÑ.FØˆC”�D“	‰Móó ˆä�x“=ˆÙ�1“ˆä�q–ˆAÜ  ¡©!¨D©G«*°a¼ÀØñBØ%™[ñB)ó :*ó +ˆGà—	‘	˜'Ÿ,™,Ó'ˆAØ×&Ñ& qÓ)ˆGØ—_‘_ QÓ'ˆFØÑŠFñ ô ˜& ! A£$¨Ó-ˆØˆà	��Ü�‹IˆÙ�1“ˆÜ�q–ˆAÜ  ¡©!¨D©G«*°aÓ>ˆGØ—	‘	˜'Ÿ,™,Ó'ˆAØ×&Ñ& qÓ)ˆGØ—_‘_ QÓ'ˆFØÑŠFñ ð ˆà	��Ü�d—i‘i¬°5ÀÑF‰ˆØ�I‰I�b‹MˆÜ! $§)¡)©Q¨t¯y©y«\¸1ÓCˆÜ�l§H¡H¨l×.?Ñ.?ÀÓ.BÀDÓIÐIô 
�Dœ$×	Ñ	 D×$4Ñ$4×$6Ñ$6Ü�T¤"¨U¸4Ñ@ÀÑCÐCô "Ð!ùòM /Gs   Å>N)c                 ó  • [        U [        SSS9u  p4XR                  ;  a  UR                  U/5      nUR	                  U5      n[        XX5      nUR                  nU" U5      nUR                  U5      S-   nXb:¼  a  [        XEU5      $ [        SS5       HÅ  n[        XXU-   S9nUR	                  UR                  5      nUR                  U5      S-   n	X–:w  a�  [        X"U-
  U-  U	U-
  -  -   5      n
[        XXS9nUR                  U5      S-   U:  aD  [        XXS9nUR	                  UR                  5      nU
S-  n
UR                  U5      S-   U:  a  MD    O   O   [        S[        U5      < S	U < 35      e[        X…U5      $ )
aÓ  Return the series expansion of an expression about 0.

Parameters
==========

expr : :class:`~.Expr`
a : :class:`~.Symbol` with respect to which expr is to be expanded
prec : order of the series expansion

Currently supports multivariate Taylor series expansion. This is much
faster that SymPy's series method as it uses sparse polynomial operations.

It automatically creates the simplest ring required to represent the series
expansion through repeated calls to sring.

Examples
========

>>> from sympy.polys.ring_series import rs_series
>>> from sympy import sin, cos, exp, tan, symbols, QQ
>>> a, b, c = symbols('a, b, c')
>>> rs_series(sin(a) + exp(a), a, 5)
1/24*a**4 + 1/2*a**2 + 2*a + 1
>>> series = rs_series(tan(a + b)*cos(a + c), a, 2)
>>> series.as_expr()
-a*sin(c)*tan(b) + a*cos(c)*tan(b)**2 + a*cos(c) + cos(c)*tan(b)
>>> series = rs_series(exp(a**QQ(1,3) + a**QQ(2, 5)), a, 1)
>>> series.as_expr()
a**(11/15) + a**(4/5)/2 + a**(2/5) + a**(2/3)/2 + a**(1/3) + 1

FTrP  rM   é	   )rB   r8   zCould not calculate z terms for )r   r   Úsymbolsrï   rð   rF  r   r&   rE   rw   r   rI   rÔ   )rG  r™   rB   r.   rI  ÚgenÚprec_gotÚmorer+   Únew_precÚprec_dos              r4   Ú	rs_seriesrl    sŠ  € ô@ �d¤2¨e¸DÑA�I€AØ—	‘	ÓØ�J‰J˜�uÓˆØ�_‰_˜QÓ€FÜ˜ aÓ.€FØ�‰€AÙ
ˆA‹$€CØ�}‰}˜SÓ! AÑ%€HàÓÜ˜ TÓ*Ð*ô ˜!˜Q–KˆDÜ˜D¨!¸±+Ñ>ˆBØ—,‘,˜rŸw™wÓ'ˆCØ—y‘y “~¨Ñ)ˆHØÓ#Ü! $°©/¸4Ñ)?ÀØñBñ *ñ #ó �ä ¨aÑ>�Ø—i‘i “n qÑ(¨4Ó/Ü# D°!ÑB�BØŸ,™, r§w¡wÓ/�CØ˜q‘L�Gð —i‘i “n qÑ(¨4Õ/ñ áñ  õ  Ü # D¦	ª4ð1ó 2ð 2ä˜ Ó&Ð&r6   )rM   )F)aÚ__doc__Úsympy.polys.domainsr   r   Úsympy.polys.ringsr   r   r   Úsympy.polys.puiseuxr   Úsympy.polys.polyerrorsr	   Úsympy.polys.monomialsr
   r   r   r   Úmpmath.libmp.libintmathr   Ú
sympy.corer   r   r   Úsympy.core.numbersr   Úsympy.core.intfuncr   Úsympy.functionsr   r   r   r   r   r   r   r   r   r   r   r   Úsympy.utilities.miscr    r!   r9   r5   r=   rE   rK   r[   r^   rs   r~   r‚   rŽ   rš   r�   r¥   r¨   rƒ   r¶   r¼   rÊ   rÎ   rÐ   rÜ   r²   rQ   rã   r�   rî   rô   rù   rõ   rþ   r   r  r  r	  r  r  r  r  r  r   r"  r&  r.  r'  r1  r3  r5  r8  rB  rU  rJ  rF  rl  rb   r6   r4   Ú<module>ry     s¡  ðñ)÷V 'ß 6Ñ 6Ý +Ý .÷2ó 2å (ß 0Ñ 0Ý 'Ý #÷2÷ 2÷ 2ó 2å 'Ý /Û òò>òò6ò2%òNò20òd%òN4òlBòH<ò.ò&ò.ò`$òLòFôPSòjò@ò@6òpòò&!/òFGòR-"ò^%"òNò.ò`ò ,'ò\+"òZò*1*òf"òH<.ò|9.òv;Tòzò )'òV*'òX,ò\,ò\/"òdò*-)ò^ô,ò<0ðh ØØØØØØØØñ

€ò
.òS"ójB'r6   