Ë
    7^(h`C  ã                  ó¶  — U d Z ddlmZ ddlmZ ddlmZmZmZm	Z	m
Z
mZmZmZ ddlmZmZ ddlmZ ddlmZmZ ddlmZ dd	lZi d
d“dd“dd“dd“dd“dd“dd“dd“dd“dd“dd“d d!“d"d#“d$d%“d&d'“d(d)“d*d+“d,d-d.d/d0d1d2d3d4d5œ	¥Zd6Z ej6                  d7ej8                  «      ZdRd8„Zd9„ Zd:„ Z d;„ Z!d<„ Z"eD � cg c]
  }  e#| «      ‘Œ c} Z$ed=d> D �cg c]
  } e%|«      ‘Œ c}Z&d?„ Z'd@„ Z(dA„ Z)dB„ Z*dC„ Z+dD„ Z,dE„ Z-dF„ Z.dG„ Z/dH„ Z0e,Z1e.Z2e0Z3dI„ Z4 G dJ„ dK«      Z5 G dL„ dM«      Z6dNe7dO<   edPk(  rdd	l8Z8e8jr                  e8jt                  fZ;y	ddQl<m=Z= d	Z8e=fZ;y	c c} w c c}w )Sz6Useful utilities for higher level polynomial classes. é    )Úannotations)ÚGROUND_TYPES)ÚSÚAddÚMulÚPowÚEqÚExprÚ
expand_mulÚexpand_multinomial)Údecompose_powerÚdecompose_power_rat)Ú_illegal)ÚPolynomialErrorÚGeneratorsError)Úbuild_optionsNÚai-  Úbi.  Úci/  Údi0  Úei1  Úfi2  Úgi3  Úhi4  Úii5  Úji6  Úki7  Úli8  Úmi9  Úni:  Úoi;  ÚpéØ   ÚqéÙ   éÚ   éÛ   éÜ   éÝ   éÞ   éß   é|   é}   é~   )	ÚrÚsÚtÚuÚvÚwÚxÚyÚziè  z^(.*?)(\d*)$c           
     óp  — t        d„ | D «       «      st        ‚t        | «      s|sg S g g fS | D ��cg c]@  }|j                  «       D �cg c]$  }|j	                  d«      j                  «       d   ‘Œ& c}‘ŒB }}}t        | «      dkD  rt        d„ |D «       «      rt        d«      ‚|D ��cg c]  \  }}|rdnd||f‘Œ }}}t        t        || «      «      }|r;g }g }|D ].  \  \  }}}}|r|j                  |«       Œ|j                  |«       Œ0 ||fS t        |Ž \  }} t        | «      S c c}w c c}}w c c}}w )a¼  Sort the numerical roots putting the real roots first, then sorting
    according to real and imaginary parts. If ``separated`` is True, then
    the real and imaginary roots will be returned in two lists, respectively.

    This routine tries to avoid issue 6137 by separating the roots into real
    and imaginary parts before evaluation. In addition, the sorting will raise
    an error if any computation cannot be done with precision.
    c              3  ó4   K  — | ]  }|j                   –— Œ y ­w©N©Ú	is_number)Ú.0r/   s     úS/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/polys/polyutils.pyú	<genexpr>z_nsort.<locals>.<genexpr>(   s   è ø€ Ò*˜qˆq�{�{Ñ*ùó   ‚é   r   é   c              3  óH   K  — | ]  }|D ]  }|j                   d k(  –— Œ Œ y­w)rB   N)Ú_prec)r=   r   r   s      r>   r?   z_nsort.<locals>.<genexpr>0   s$   è ø€ ÒC¨qÀÒC¸A˜aŸg™g¨�lÐC˜lÑCùs   ‚ "z%could not compute root with precision)
ÚallÚNotImplementedErrorÚlenÚas_real_imagr    ÚanyÚsortedÚzipÚappendÚlist)ÚrootsÚ	separatedr/   r   ÚkeyÚimÚ_r3   s           r>   Ú_nsortrS      s4  € ô Ñ* EÔ*Ô*Ü!Ð!ÜˆuŒ:Ù"ˆrÐ0¨¨R¨Ð0ð JO×
OÀA¨a¯n©nÓ.>Ö?¨ˆA�C‰C�‹F×ÑÓ! !Ó$Ô?Ð
O€CÑ
Oä
ˆ5ƒz�A‚~œ#ÑC°CÔCÔCÜ!Ð"IÓJÐJà-0×
1¡T Q¨‘‰A˜˜1˜aÒ Ð
1€CÑ
1Ü
”�S˜%“Ó
!€CáØˆØˆØ ò 	‰M‰JˆR��A˜ÙØ—‘˜•à—‘˜•ð		ð
 �!ˆtˆÜ�Cˆy�H€A€uÜ�‹;Ðùò% @ùÓ
Oùó
 2s   ±D,Á)D'Á1D,Â)D2Ä'D,c                ó  ‡‡— t        |«      }i dcŠŠ|�4i |j                  cŠŠt        |j                  «      D ]  \  }}|dz   ‰|<   Œ ˆˆfd„}	 t	        | |¬«      } t        | «      S # t
        $ r Y t        | «      S w xY w)z1Sort generators in a reasonably intelligent way. NrB   c                óf  •— t        | «      } ‰�"	 t        ‰«       ‰j                  | «      z   | dfS t        j                  | «      j                  «       \  }}|rt        |«      }nd}	 ‰|   ||fS # t        $ r Y ŒJw xY w# t        $ r Y nw xY w	 t        |   ||fS # t        $ r Y nw xY wt        ||fS )Nr   )ÚstrrG   ÚindexÚ
ValueErrorÚ_re_genÚmatchÚgroupsÚintÚKeyErrorÚ_gens_orderÚ
_max_order)ÚgenÚnamerW   Ú
gens_orderÚwrts      €€r>   Ú	order_keyz_sort_gens.<locals>.order_keyO   sÚ   ø€ Ü�#‹hˆàˆ?ðÜ˜S›˜	 C§I¡I¨c£NÑ2°C¸Ð;Ð;ô —m‘m CÓ(×/Ñ/Ó1‰ˆˆeáÜ˜“J‰EàˆEð	Ø Ñ% t¨UÐ3Ð3øô ò Ùðûô ò 	Ùð	úð	Ü Ñ% t¨UÐ3Ð3øÜò 	Ùð	úô ˜D %Ð(Ð(s5   � A0 Á(A? Á0	A<Á;A<Á?	BÂ
BÂB Â	B'Â&B'©rP   )r   rc   Ú	enumerateÚsortrJ   Ú	TypeErrorÚtuple)ÚgensÚargsÚoptr   r`   rd   rb   rc   s         @@r>   Ú
_sort_gensrm   C   s•   ù€ ä
˜Ó
€Cà˜$€O€J�à
€Ø˜cŸg™gˆˆ
�Cä §¡Ó)ò 	$‰FˆAˆsØ !™eˆJ�sŠOð	$õ)ð8Ü�d 	Ô*ˆô �‹;Ðøô ò Øä�‹;Ððús   ÁA( Á(	A>Á=A>c                ó  — t        | «      } t        |«      }| |k(  rt        | «      S g g d}}}| D ]  }||v sŒ|j                  |«       Œ t        |«      D ]  \  }}||v sŒ||   |dz   c||<   }Œ |D ]m  }| j	                  |«      }|j                  | d| «       | |dz   d } |j	                  |«      }|j                  |d| «       ||dz   d }|j                  |«       Œo |j                  | «       |j                  |«       t        |«      S )z2Unify generators in a reasonably intelligent way. r   rB   N)rM   ri   rL   rf   rW   Úextend)Úf_gensÚg_gensrj   Úcommonr   r`   r   s          r>   Ú_unify_gensrs   s   s,  € ä�&‹\€FÜ�&‹\€Fà�ÒÜ�V‹}Ðà˜"˜a�!ˆ&€Dàò ˆØ�&Š=Ø�M‰M˜#Õðô ˜FÓ#ò ,‰ˆˆ3Ø�&Š=Ø! !™9 a¨!¡eˆLˆF�1‰I‘qð,ð ò ˆØ�L‰L˜Óˆà�‰�F˜2˜A�JÔØ˜˜A™˜�ˆà�L‰L˜Óˆà�‰�F˜2˜A�JÔØ˜˜A™˜�ˆà�‰�CÕðð 	‡K�K�ÔØ‡K�K�Ôä�‹;Ðó    c                ón   — t        | «      dk(  rt        | d   d«      rt        | d   «      S t        | «      S )z8Support for passing generators as `*gens` and `[gens]`. rB   r   Ú__iter__)rG   Úhasattrri   )rj   s    r>   Ú_analyze_gensrx   ˜   s2   € ä
ˆ4ƒy�A‚~œ' $ q¡'¨:Ô6Ü�T˜!‘W‹~Ðä�T‹{Ðrt   c                óz   ‡— ˆfd„Šˆfd„}ˆfd„}|j                  dd«      rt        | |¬«      S t        | |¬«      S )z9Sort low-level factors in increasing 'complexity' order. c                ó”   •— t        | t        «      rt        | «      S t        | t        «      r| D �cg c]
  } ‰|«      ‘Œ c}S | S c c}w r:   )Ú
isinstanceÚ	_GF_typesr\   rM   )Úfactorr   rd   s     €r>   rd   z _sort_factors.<locals>.order_key¦   s@   ø€ Ü�fœiÔ(Ü�v“;ÐÜ˜¤Ô%Ø*0Ö1 Q‘I˜a•LÒ1Ð1àˆMùò 2s   ±Ac                ó6   •— | \  }}t        |«      | ‰|«      fS r:   ©rG   )r}   r   r    rd   s      €r>   Úorder_if_multiple_keyz,_sort_factors.<locals>.order_if_multiple_key®   s!   ø€ Ø‰ˆˆAÜ�A“˜™9 Q›<Ð(Ð(rt   c                ó*   •— t        | «       ‰| «      fS r:   r   )r   rd   s    €r>   Úorder_no_multiple_keyz,_sort_factors.<locals>.order_no_multiple_key²   s   ø€ Ü�A“™	 !›Ð%Ð%rt   ÚmultipleTre   )ÚgetrJ   )Úfactorsrk   r€   r‚   rd   s       @r>   Ú_sort_factorsr†       s>   ø€ ôô)ô&ð ‡x�x�
˜DÔ!Ü�gÐ#8Ô9Ð9ä�gÐ#8Ô9Ð9rt   rB   é   c                óv   — t        | «      t        v s| t        v ryt        | t        «      rt	        | «      | k7  ryy)zBDo not treat NaN and infinities as valid polynomial coefficients. TN)ÚtypeÚillegal_typesÚfinfr{   Úfloat©Úexprs    r>   Ú_not_a_coeffr�   ¿   s2   € äˆDƒz”]Ñ" d¬d¡lØÜ�$œÔ¤5¨£;°$Ò#6ØØ
rt   c                ó|  — t        |j                  «      i }}t        |j                  «      D ]
  \  }}|||<   Œ g }| D �]%  }i }|j                  r|j                  |j
                  z
  }t        j                  |«      D ]Ò  }	g dg|z  }}
t        j                  |	«      D ]‚  }t        |«      s|j                  r|
j                  |«       Œ,	 |j                  du r2t        |«      \  }}|dk  r-| t        |t        j                    «      }}nt#        |«      \  }}||||   <   Œ„ t+        |«      }||v r||xx   t        |
Ž z  cc<   ŒÈt        |
Ž ||<   ŒÔ |j                  |«       �Œ( ||j                  fS # t$        $ r=  |j&                  |j                  Ž s|
j                  |«       nt)        d|z  «      ‚Y �Œw xY w)z@Transform expressions into a multinomial form given generators. r   Fz0%s contains an element of the set of generators.)rG   rj   rf   Úis_EqualityÚlhsÚrhsr   Ú	make_argsr   r�   Ú	is_NumberrL   Úseriesr   r   r   ÚOner   r]   Úhas_freer   ri   )Úexprsrl   r   Úindicesr   r   ÚpolysrŽ   ÚpolyÚtermÚcoeffÚmonomr}   ÚbaseÚexps                  r>   Ú _parallel_dict_from_expr_if_gensr¢   È   sË  € ä�S—X‘X“ €w€Aä˜#Ÿ(™(Ó#ò ‰ˆˆ1Øˆ�Š
ðð €Eàó %ˆØˆà×ÒØ—8‘8˜dŸh™hÑ&ˆDä—M‘M $Ó'ò 	*ˆDØ ˜s 1™u�5ˆEäŸ-™-¨Ó-ò U�Ü# FÔ+°×0@Ò0@Ø—L‘L Õ(ðUØŸ:™:¨Ñ.Ü(7¸Ó(?™I˜D #à" QšwØ-0¨D´#°d¼Q¿U¹U¸FÓ2C T¡ä(;¸FÓ(C™I˜D #à/2˜˜g d™mÒ,ðUô* ˜%“LˆEà˜‰}Ø�U“œs E˜{Ñ*”ä! 5˜k��U’ð;	*ð> 	�‰�TÖðK%ðN �#—(‘(ˆ?Ðøô! $ò UØ.˜vŸ™°·±Ñ9Ø!ŸL™L¨Õ0ä"1ð 3KØMSñ3Tó #Uð Uò 1ðUús   ÃAE5Å5AF;	Æ:F;	c                óh  ‡— ‰j                   �ˆfd„}n'‰j                  du rd„ }n‰j                  durd„ }nd„ }t        «       g }}| D �].  }g }|j                  r|j
                  |j                  z
  }t        j                  |«      D ]Û  }g i }	}t        j                  |«      D ]ª  }
t        |
«      s&|
j                  s ||
«      r|j                  |
«       Œ4‰j                  du r2t        |
«      \  }}|dk  r-| t        |t         j"                   «      }}nt%        |
«      \  }}|	j'                  |d«      |z   |	|<   |j)                  |«       Œ¬ |j                  ||	f«       ŒÝ |j                  |«       �Œ1 t+        |‰¬«      }t-        |«      i }}t/        |«      D ]
  \  }}|||<   Œ g }|D ]s  }i }|D ]Y  \  }}dg|z  }|j1                  «       D ]  \  }}||||   <   Œ t3        |«      }||v r||xx   t        |Ž z  cc<   ŒOt        |Ž ||<   Œ[ |j                  |«       Œu |t3        |«      fS )	zITransform expressions into a multinomial form and figure out generators. c                ó    •— | ‰j                   v S r:   )Údomain)r}   rl   s    €r>   Ú	_is_coeffz3_parallel_dict_from_expr_no_gens.<locals>._is_coeffþ   s   ø€ Ø˜SŸZ™ZÐ'Ð'rt   Tc                ó   — | j                   S r:   )Úis_algebraic©r}   s    r>   r¦   z3_parallel_dict_from_expr_no_gens.<locals>._is_coeff  s   € Ø×&Ñ&Ð&rt   Fc                ó&   — | t         j                  u S r:   )r   ÚImaginaryUnitr©   s    r>   r¦   z3_parallel_dict_from_expr_no_gens.<locals>._is_coeff  s   € ØœQŸ_™_Ð,Ð,rt   c                ó   — | j                   S r:   r;   r©   s    r>   r¦   z3_parallel_dict_from_expr_no_gens.<locals>._is_coeff  s   € Ø×#Ñ#Ð#rt   r   )rl   )r¥   Ú	extensionÚgreedyÚsetr‘   r’   r“   r   r”   r   r�   r•   rL   r–   r   r   r   r—   r   Ú
setdefaultÚaddrm   rG   rf   Úitemsri   )r™   rl   r¦   rj   ÚreprsrŽ   Útermsr�   rž   Úelementsr}   r    r¡   r   rš   r   r   r›   rœ   rŸ   s    `                  r>   Ú _parallel_dict_from_expr_no_gensr¶   û   sJ  ø€ à
‡z�zÐõ	(à	�‰˜$Ñ	ó	'à	�‰˜5Ñ	 ó	-ò	$ô “%˜ˆ%€Dàó ˆØˆà×ÒØ—8‘8˜dŸh™hÑ&ˆDä—M‘M $Ó'ò 	,ˆDØ  "�8ˆEäŸ-™-¨Ó-ò #�Ü# FÔ+°×1AÒ1AÁYÈvÔEVØ—L‘L Õ(à—z‘z UÑ*Ü$3°FÓ$;™	˜˜cà š7Ø),¨¬c°$¼¿¹¸Ó.? ™Cä$7¸Ó$?™	˜˜cà%-×%8Ñ%8¸¸qÓ%AÀCÑ%G�H˜T‘NØ—H‘H˜T•Nð#ð �L‰L˜% Ð*Õ+ð%	,ð( 	�‰�UÖð5ô8 �d Ô$€DÜ�T“˜B€w€Aä˜$“ò ‰ˆˆ1Øˆ�Š
ðð €Eàò ˆØˆà ò 	*‰KˆE�4Ø�C˜‘EˆEà!ŸZ™Z›\ò +‘	��cØ'*��g˜d‘mÒ$ð+ô ˜%“LˆEà˜‰}Ø�U“œs E˜{Ñ*”ä! 5˜k��U’ð	*ð 	�‰�TÕð!ð$ ”%˜“+ÐÐrt   c                ó.   — t        | f|«      \  \  }}||fS )zBTransform an expression into a multinomial form given generators. )r¢   ©rŽ   rl   rœ   rj   s       r>   Ú_dict_from_expr_if_gensr¹   E  ó    € ä4°d°W¸cÓB�M�G€TˆTØ�ˆ:Ðrt   c                ó.   — t        | f|«      \  \  }}||fS )zKTransform an expression into a multinomial form and figure out generators. )r¶   r¸   s       r>   Ú_dict_from_expr_no_gensr¼   K  rº   rt   c                óN   — t        | t        |«      «      \  }}||j                  fS )ú/Transform expressions into a multinomial form. )Ú_parallel_dict_from_exprr   rj   )r™   rk   Úrepsrl   s       r>   Úparallel_dict_from_exprrÁ   Q  s%   € ä(¨´¸dÓ0CÓD�I€Dˆ#Ø�—‘ˆ>Ðrt   c                ó  — |j                   dur| D �cg c]  }|j                  «       ‘Œ } }t        d„ | D «       «      rt        d«      ‚|j                  rt	        | |«      \  }}nt        | |«      \  }}||j                  d|i«      fS c c}w )r¾   Fc              3  ó8   K  — | ]  }|j                   d u –— Œ y­w)FN)Úis_commutative)r=   rŽ   s     r>   r?   z+_parallel_dict_from_expr.<locals>.<genexpr>\  s   è ø€ Ò
:¨Dˆ4×Ñ %Ô'Ñ
:ùs   ‚ú-non-commutative expressions are not supportedrj   )ÚexpandrI   r   rj   r¢   r¶   Úclone)r™   rl   rŽ   rÀ   rj   s        r>   r¿   r¿   W  s…   € à
‡z�z˜ÑØ,1Ö3 D�$—+‘+•-Ð3ˆÐ3ä
Ñ
:°EÔ
:Ô:ÜÐMÓNÐNà
‡x‚xÜ5°e¸SÓA‰
ˆ‰dä5°e¸SÓA‰
ˆˆdà�—‘˜F D˜>Ó*Ð*Ð*ùò 4s   “B	c                óN   — t        | t        |«      «      \  }}||j                  fS )ú1Transform an expression into a multinomial form. )Ú_dict_from_exprr   rj   )rŽ   rk   Úreprl   s       r>   Údict_from_exprrÌ   g  s%   € ä˜t¤]°4Ó%8Ó9�H€CˆØ�—‘ˆ=Ðrt   c                óš  ‡— | j                   du rt        d«      ‚d„ Š|j                  durát        | t        t
        f«      st        d«      ‚| j                  «       } t        ˆfd„t        j                  | «      D «       «      r3t        | «      } t        ˆfd„t        j                  | «      D «       «      rŒ3t        d„ t        j                  | «      D «       «      r1t        | «      } t        d„ t        j                  | «      D «       «      rŒ1|j                  rt        | |«      \  }}nt        | |«      \  }}||j                  d|i«      fS )rÉ   FrÅ   c                óª   — | j                   xrF | j                  j                  xr. | j                  j                  xr | j                  j
                  S r:   )Úis_Powr¡   Úis_positiveÚ
is_Integerr    Úis_Addr�   s    r>   Ú_is_expandable_powz+_dict_from_expr.<locals>._is_expandable_powr  sB   € Ø—‘ò % §¡× 4Ñ 4ò %¸¿¹×9LÑ9Lò %Ø—I‘I×$Ñ$ð	&rt   zexpression must be of type Exprc              3  óŠ   •K  — | ]:  } ‰|«      xs, |j                   xr t        ˆfd „|j                  D «       «      –— Œ< y­w)c              3  ó.   •K  — | ]  } ‰|«      –— Œ y ­wr:   © )r=   r   rÓ   s     €r>   r?   z,_dict_from_expr.<locals>.<genexpr>.<genexpr>|  s   øè ø€ Ò6¨!Ñ" 1×%Ñ6ùs   ƒN©Úis_MulrI   rk   )r=   r   rÓ   s     €r>   r?   z"_dict_from_expr.<locals>.<genexpr>{  sE   øè ø€ ò %Ø;<ñ % QÓ'ò 7¨1¯8©8ò ,7ÜÓ6¨q¯v©vÔ6Ó6ó7ñ %ùs   ƒA Ac              3  óp   K  — | ].  }|j                   xr t        d „ |j                  D «       «      –— Œ0 y­w)c              3  ó4   K  — | ]  }|j                   –— Œ y ­wr:   )rÒ   )r=   r   s     r>   r?   z,_dict_from_expr.<locals>.<genexpr>.<genexpr>€  s   è ø€ Ò"<° 1§8¥8Ñ"<ùr@   Nr×   )r=   r   s     r>   r?   z"_dict_from_expr.<locals>.<genexpr>€  s+   è ø€ ÒZÀ�!—(‘(Ò<œsÑ"<°Q·V±VÔ"<Ó<Ó<ÑZùs   ‚46rj   )rÄ   r   rÆ   r{   r
   r	   rI   r   r”   r   r   rj   r¹   r¼   rÇ   )rŽ   rl   rË   rj   rÓ   s       @r>   rÊ   rÊ   m  s  ø€ à×Ñ˜eÑ#ÜÐMÓNÐNò&ð ‡z�z˜ÑÜ˜$¤¤r 
Ô+Ü!Ð"CÓDÐDØ�{‰{‹}ˆäó %ä—‘˜dÓ#ô%ô %ô & dÓ+ˆDô	 ó %ä—‘˜dÓ#ô%õ %ô
 ÑZÄcÇmÁmÐTXÓFYÔZÔZÜ˜dÓ#ˆDô ÑZÄcÇmÁmÐTXÓFYÔZÕZð ‡x‚xÜ+¨D°#Ó6‰	ˆ‰Tä+¨D°#Ó6‰	ˆˆTà�—	‘	˜6 4˜.Ó)Ð)Ð)rt   c                óÞ   — g }| j                  «       D ]Q  \  }}|g}t        ||«      D ]#  \  }}|sŒ	|j                  t        ||«      «       Œ% |j                  t	        |Ž «       ŒS t        |Ž S )z/Convert a multinomial form into an expression. )r²   rK   rL   r   r   r   )rË   rj   ÚresultrŸ   rž   r�   r   r   s           r>   Úexpr_from_dictrÝ   ‹  st   € à€FàŸ	™	›ò "‰ˆˆuØˆwˆÜ˜˜eÓ$ò 	'‰DˆAˆqÚØ—‘œC  1›IÕ&ð	'ð 	�‰”c˜4�jÕ!ð"ô �ˆ<Ðrt   c                ó,  — t        |«      }| j                  «       }| j                  «       }t        t	        | «      «      D �cg c]  }g ‘Œ }}t        «       }|D ]M  }	 |j                  |«      }	|j                  |	«       t        ||«      D ]  \  }
}|j                  |
|	   «       Œ ŒO t        |«      D ]!  \  }}||vsŒ|D ]  }||   sŒ	t        d«      ‚ Œ# t        t        |«      |fS c c}w # t        $ r |D ]  }|j                  d«       Œ Y Œ¹w xY w)z*Reorder levels using dict representation. r   zunable to drop generators)rM   ÚkeysÚvaluesÚrangerG   r¯   rW   r±   rK   rL   rX   rf   r   Úmapri   )rË   rj   Únew_gensÚmonomsÚcoeffsrR   Ú
new_monomsÚused_indicesr`   r   ÚMÚnew_Mr   rŸ   s                 r>   Ú_dict_reorderrê   ž  s'  € ä�‹:€Dà�X‰X‹Z€FØ�Z‰Z‹\€Fä$¤S¨£X›Ö0˜!’2Ð0€JÐ0Ü“5€Làò 	 ˆð	 Ø—
‘
˜3“ˆAØ×Ñ˜QÔä ¨
Ó3ò #‘��5Ø—‘˜Q˜q™TÕ"ñ#ð	 ô ˜$“ò G‰ˆˆ1Ø�LÒ Øò G�Ø˜“8Ü)Ð*EÓFÐFñGðGô Œu�jÓ! 6Ð)Ð)ùò) 1øô ò 	 Ø#ò  �Ø—‘˜Q•ò ð	 ús   Á	C*ÁA
C/Ã/!DÄDc                  ó"   — e Zd ZdZdZdd„Zd„ Zy)ÚPicklableWithSlotsaÄ  
    Mixin class that allows to pickle objects with ``__slots__``.

    Examples
    ========

    First define a class that mixes :class:`PicklableWithSlots` in::

        >>> from sympy.polys.polyutils import PicklableWithSlots
        >>> class Some(PicklableWithSlots):
        ...     __slots__ = ('foo', 'bar')
        ...
        ...     def __init__(self, foo, bar):
        ...         self.foo = foo
        ...         self.bar = bar

    To make :mod:`pickle` happy in doctest we have to use these hacks::

        >>> import builtins
        >>> builtins.Some = Some
        >>> from sympy.polys import polyutils
        >>> polyutils.Some = Some

    Next lets see if we can create an instance, pickle it and unpickle::

        >>> some = Some('abc', 10)
        >>> some.foo, some.bar
        ('abc', 10)

        >>> from pickle import dumps, loads
        >>> some2 = loads(dumps(some))

        >>> some2.foo, some2.bar
        ('abc', 10)

    rÖ   Nc                ó  — |€| j                   }i }|j                  D ]@  }t        |dd «      }t        t        dd «      }|€Œ$||usŒ)|j	                   || |«      «       ŒB |j
                  D ]  }t        | |«      sŒt        | |«      ||<   Œ  |S )NÚ__getstate__)Ú	__class__Ú	__bases__ÚgetattrÚobjectÚupdateÚ	__slots__rw   )ÚselfÚclsr   r   ÚgetstateÚobjstatera   s          r>   rî   zPicklableWithSlots.__getstate__ä  sž   € Øˆ;à—.‘.ˆCàˆð —‘ò 		,ˆAô ˜q .°$Ó7ˆHÜœv ~°tÓ<ˆHØÑ#¨¸Ò(@Ø—‘™ $¨Ó*Õ+ð		,ð —M‘Mò 	.ˆDÜ�t˜TÕ"Ü! $¨Ó-��$’ð	.ð ˆrt   c                óN   — |j                  «       D ]  \  }}t        | ||«       Œ y r:   )r²   Úsetattr)rõ   r   ra   Úvalues       r>   Ú__setstate__zPicklableWithSlots.__setstate__þ  s'   € àŸ7™7›9ò 	'‰KˆD�%Ü�D˜$ Õ&ñ	'rt   r:   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__rô   rî   rü   rÖ   rt   r>   rì   rì   ¼  s   „ ñ#ðJ €Ióó4'rt   rì   c                  ó,   — e Zd ZdZdd„Zdd„Zd„ Zd„ Zy)ÚIntegerPowerablea¢  
    Mixin class for classes that define a `__mul__` method, and want to be
    raised to integer powers in the natural way that follows. Implements
    powering via binary expansion, for efficiency.

    By default, only integer powers $\geq 2$ are supported. To support the
    first, zeroth, or negative powers, override the corresponding methods,
    `_first_power`, `_zeroth_power`, `_negative_power`, below.
    Nc                ó´  — |dk  r>	 |dk(  r| j                  «       S |dk(  r| j                  «       S | j                  ||¬«      S t        t        |«      dd  «      D �cg c]  }t        |«      ‘Œ }}t        |«      }| }d}t        |«      D ]0  }||   r|r|}	d}n	|z  }	|�|	|z  }	||dz
  k  sŒ$||z  }|€Œ,||z  }Œ2 	S # t        $ r	 t        cY S w xY wc c}w )NrA   rB   r   )ÚmoduloTF)
Ú_first_powerÚ_zeroth_powerÚ_negative_powerrF   ÚNotImplementedÚreversedÚbinr\   rG   rá   )
rõ   r   r  r   Úbitsr    r"   Úfirstr   r/   s
             r>   Ú__pow__zIntegerPowerable.__pow__  s  € ØˆqŠ5ð&Ø˜’6Ø×,Ñ,Ó.Ð.Ø˜!’VØ×-Ñ-Ó/Ð/à×/Ñ/°¸&Ð/ÓAÐAô %-¬S°«V°A°B¨ZÓ$8Ö9˜q”C˜•FÐ9ˆDÐ9Ü�D“	ˆAØˆAØˆEÜ˜1“Xò $�Ø˜’7ÙØ˜Ø %™à˜Q™˜Ø!Ð-Ø ™K˜AØ�q˜1‘u“9Ø˜‘F�AØÑ)Ø˜V™™ð$ð ˆHøô) 'ò &Ü%Ò%ð&üò :s!   ‡C  œC  ±C  ÁCÃ CÃCc                ó   — t         ‚)z¹
        Compute inverse of self, then raise that to the abs(e) power.
        For example, if the class has an `inv()` method,
            return self.inv() ** abs(e) % modulo
        ©rF   )rõ   r   r  s      r>   r  z IntegerPowerable._negative_power.  s
   € ô "Ð!rt   c                ó   — t         ‚)z?Return unity element of algebraic struct to which self belongs.r  ©rõ   s    r>   r  zIntegerPowerable._zeroth_power6  ó   € ä!Ð!rt   c                ó   — t         ‚)zReturn a copy of self.r  r  s    r>   r  zIntegerPowerable._first_power:  r  rt   r:   )rý   rþ   rÿ   r   r  r  r  r  rÖ   rt   r>   r  r    s   „ ñóó>"ò"ó"rt   r  ztuple[type, ...]r|   Úflint)ÚModularInteger)F)>r   Ú
__future__r   Úsympy.external.gmpyr   Ú
sympy.corer   r   r   r   r	   r
   r   r   Úsympy.core.exprtoolsr   r   Úsympy.core.numbersr   Úsympy.polys.polyerrorsr   r   Úsympy.polys.polyoptionsr   Úrer^   r_   ÚcompileÚ	MULTILINErY   rS   rm   rs   rx   r†   r‰   rŠ   rŒ   r‹   r�   r¢   r¶   r¹   r¼   rÁ   r¿   rÌ   rÊ   rÝ   Úparallel_dict_from_basicÚdict_from_basicÚbasic_from_dictrê   rì   r  Ú__annotations__r  ÚnmodÚfmpz_modr|   Ú"sympy.polys.domains.modularintegerr  )Úobjr   s   00r>   ú<module>r(     s  ðÚ <å "å ,÷$÷ $ó $ç EÝ 'ß CÝ 1ã 	ðØˆðØ�3ðØ˜SðØ"% sðàˆðà�3ðà˜Sðà"% sðð ˆðð �3ðð ˜Sðð #& sðð ˆð	ð �3ð	ð ˜Sð	ð #& sð	ð
 ˆðð
 ˜S sØ	�3˜S sØ	�3ò€ð €
Ø
ˆ"�*‰*�_ b§l¡lÓ
3€ó!òH-ò`"òJò:ð6 '/Ö/˜s‘�c•Ò/€Ø" 1 Q˜-Ö(�Q‰ˆa�Ò(€òò0òfGòTòòò+ò ò*ò<ð 3Ð Ø €Ø €ò*÷<E'ñ E'÷P8"ñ 8"ðv Ó ð �7ÒÛØ—‘˜UŸ^™^Ð,�IåAØ€EØÐ!�Iùò[ 0ùÚ(s   Â8EÃE