ó
    Š*£h`C  ã                  óÆ  • % S 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  SSKJrJr  SSKJr  SSKJrJr  SSKJr  SS	Kr0 S
S_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_S S!_S"S#_S$S%_S&S'_S(S)_S*S+_S,S-S.S/S0S1S2S3S4S5.	ErS6r\R6                  " S7\R8                  5      rSRS8 jrS9 rS: r S; r!S< r"\ V s/ s H  n \#" U 5      PM     sn r$\S=S>  Vs/ s H  n\%" U5      PM     snr&S? r'S@ r(SA r)SB r*SC r+SD r,SE r-SF r.SG r/SH r0\,r1\.r2\0r3SI r4 " SJ SK5      r5 " SL SM5      r6SN\7SO'   \SP:X  a  SS	K8r8\8Rr                  \8Rt                  4r;g	SSQK<J=r=  S	r8\=4r;g	s  sn f s  snf )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           
     óÀ  • [        S U  5       5      (       d  [        e[        U 5      (       d  U(       d  / $ / / 4$ U  VVs/ s HB  o"R                  5        Vs/ s H$  o3R	                  S5      R                  5       S   PM&     snPMD     nnn[        U 5      S:”  a"  [        S U 5       5      (       a  [        S5      eU VVs/ s H  u  p#U(       a  SOSX#4PM     nnn[        [        X@5      5      nU(       aA  / n/ nU H4  u  u  n  pgU(       a  UR                  U5        M#  UR                  U5        M6     X#4$ [        U6 u  p`[        U 5      $ s  snf s  snnf s  snnf )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  ó8   #   • U  H  oR                   v •  M     g 7f©N©Ú	is_number)Ú.0r/   s     ÚR/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/polys/polyutils.pyÚ	<genexpr>Ú_nsort.<locals>.<genexpr>(   s   é € Ð*¢E˜q�{Ž{¢Eùó   ‚é   r   é   c              3  óP   #   • U  H  o  H  o"R                   S :H  v •  M     M     g7f)rC   N)Ú_prec)r=   r   r   s      r>   r?   r@   0   s   é € ÐC²C¨qÃ¸AŸg™g¨žlÁ™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>   Ú_nsortrT      s/  € ô Ñ*¡EÓ*×*Ñ*Ü!Ð!Üˆu�:‰:Þ"ˆrÐ0¨¨R¨Ð0ñ JOÔ
OÊÀA¯n©nÔ.>Ó?Ò.>¨�C‰C�‹F×ÑÓ! !Ô$Ñ.>Ô?É€CÑ
Oä
ˆ5ƒz�Aƒ~œ#ÑC±CÓC×CÑCÜ!Ð"IÓJÐJá-0Ô
1ªS¡T Q–‰A˜˜1Ó ©S€CÑ
1Ü
”�S“Ó
!€CæØˆØˆÛ ‰M‰JˆR��AÞØ—‘˜–à—‘˜–ñ	 !ð
 ˆtˆÜ�Cˆy�H€AÜ�‹;Ðùò% @ùÓ
Oùó
 2s   Á EÁ+EÂEÃEÅEc                óî   ^^• [        U5      n0 SsmmUb5  0 UR                  smm[        UR                  5       H  u  p4US-   TU'   M     UU4S jn [	        XS9n [        U 5      $ ! [
         a     Nf = f)z1Sort generators in a reasonably intelligent way. NrC   c                óp  >• [        U 5      n Tb"   [        T5      * TR                  U 5      -   U S4$ [        R                  U 5      R                  5       u  pU(       a  [        U5      nOSn TU   X4$ ! [         a     NNf = f! [         a     Of = f [        U   X4$ ! [         a     Of = f[        X4$ )Nr   )ÚstrrH   ÚindexÚ
ValueErrorÚ_re_genÚmatchÚgroupsÚintÚKeyErrorÚ_gens_orderÚ
_max_order)ÚgenÚnamerX   Ú
gens_orderÚwrts      €€r>   Ú	order_keyÚ_sort_gens.<locals>.order_keyO   sÒ   ø€ Ü�#‹hˆà‰?ðÜ˜S›˜	 C§I¡I¨c£NÑ2°C¸Ð;Ð;ô —m‘m CÓ(×/Ñ/Ó1‰ˆæÜ˜“J‰EàˆEð	Ø Ñ% tÐ3Ð3øô ó Ùðûô ó 	Ùð	úð	Ü Ñ% tÐ3Ð3øÜó 	Ùð	úô ˜DÐ(Ð(s5   ‘ A4 Á-B Á4
BÂ BÂ
BÂBÂ
B  Â 
B-Â,B-©rQ   )r   rd   Ú	enumerateÚsortrK   Ú	TypeErrorÚtuple)ÚgensÚargsÚoptr   ra   re   rc   rd   s         @@r>   Ú
_sort_gensro   C   s‚   ù€ ä
˜Ó
€Cà˜$€O€J�à
�Ø˜cŸg™gˆˆ
�Cä §¡Ö)‰FˆAØ !™eˆJ�s‹Oñ *ö)ð8Ü�dÑ*ˆô �‹;Ðøô ó Ùðús   Á	A' Á'
A4Á3A4c                ó&  • [        U 5      n [        U5      nX:X  a  [        U 5      $ / / SpCnU  H  nXQ;   d  M
  UR                  U5        M     [        U5       H  u  peXS;   d  M  X4   US-   sX'   nM     U Hl  nU R	                  U5      nUR                  U SU 5        XS-   S n UR	                  U5      nUR                  USU 5        XS-   S nUR                  U5        Mn     UR                  U 5        UR                  U5        [        U5      $ )z2Unify generators in a reasonably intelligent way. r   rC   N)rN   rk   rM   rh   rX   Úextend)Úf_gensÚg_gensrl   Úcommonr   ra   r   s          r>   Ú_unify_gensru   s   s  € ä�&‹\€FÜ�&‹\€FàÓÜ�V‹}Ðà˜"˜a�!€DãˆØ�=Ø�M‰M˜#Öñ ô ˜FÖ#‰ˆØ�=Ø!™9 a¨!¡eˆLˆF‰I’qñ $ó ˆØ�L‰L˜Óˆà�‰�F˜2˜A�JÔØ˜A™˜�ˆà�L‰L˜Óˆà�‰�F˜2˜A�JÔØ˜A™˜�ˆà�‰�CÖñ ð 	‡K�K�ÔØ‡K�K�Ôä�‹;Ðó    c                óz   • [        U 5      S:X  a"  [        U S   S5      (       a  [        U S   5      $ [        U 5      $ )z8Support for passing generators as `*gens` and `[gens]`. rC   r   Ú__iter__)rH   Úhasattrrk   )rl   s    r>   Ú_analyze_gensrz   ˜   s5   € ä
ˆ4ƒy�Aƒ~œ' $ q¡'¨:×6Ñ6Ü�T˜!‘W‹~Ðä�T‹{Ðrv   c                óz   ^• U4S jmU4S jnU4S jnUR                  SS5      (       a	  [        XS9$ [        XS9$ )z9Sort low-level factors in increasing 'complexity' order. c                ó®   >• [        U [        5      (       a  [        U 5      $ [        U [        5      (       a  U  Vs/ s H  nT" U5      PM     sn$ U $ s  snf r:   )Ú
isinstanceÚ	_GF_typesr]   rN   )Úfactorr   re   s     €r>   re   Ú _sort_factors.<locals>.order_key¦   sJ   ø€ Ü�fœi×(Ñ(Ü�v“;ÐÜ˜¤×%Ñ%Ù*0Ó1ª& Q‘I˜a–L©&Ñ1Ð1àˆMùò 2s   »Ac                ó4   >• U u  p[        U5      UT" U5      4$ r:   ©rH   )r   r   r    re   s      €r>   Úorder_if_multiple_keyÚ,_sort_factors.<locals>.order_if_multiple_key®   s   ø€ Ø‰ˆÜ�A“˜™9 Q›<Ð(Ð(rv   c                ó*   >• [        U 5      T" U 5      4$ r:   r‚   )r   re   s    €r>   Úorder_no_multiple_keyÚ,_sort_factors.<locals>.order_no_multiple_key²   s   ø€ Ü�A“™	 !›Ð%Ð%rv   ÚmultipleTrg   )ÚgetrK   )Úfactorsrm   rƒ   r†   re   s       @r>   Ú_sort_factorsr‹       s;   ø€ õõ)õ&ð ‡x�x�
˜D×!Ñ!Ü�gÑ9Ð9ä�gÑ9Ð9rv   rC   é   c                óŠ   • [        U 5      [        ;   d
  U [        ;   a  g[        U [        5      (       a  [	        U 5      U :w  a  gg)zBDo not treat NaN and infinities as valid polynomial coefficients. TN)ÚtypeÚillegal_typesÚfinfr}   Úfloat©Úexprs    r>   Ú_not_a_coeffr”   ¿   s5   € äˆDƒz”]Ó" d¬d£lØÜ�$œ×Ñ¤5¨£;°$Ó#6ØØ
rv   c                ó¬  • [        UR                  5      0 p2[        UR                  5       H	  u  pEXCU'   M     / nU  GH8  n0 nUR                  (       a  UR                  UR
                  -
  n[        R                  " U5       HÝ  n	/ S/U-  pº[        R                  " U	5       H‹  n[        U5      (       d$  UR                  (       a  U
R                  U5        M7   UR                  SL a1  [        U5      u  pÞUS:  a  U* [        U[        R                   * 5      pÞO[#        U5      u  pÞXëX=   '   M�     [+        U5      nX¸;   a  X‹==   [        U
6 -  ss'   MÓ  [        U
6 X‹'   Mß     UR                  U5        GM;     XaR                  4$ ! [$         aB    UR&                  " UR                  6 (       d  U
R                  U5         GM!  [)        SU-  5      ef = f)z@Transform expressions into a multinomial form given generators. r   Fz0%s contains an element of the set of generators.)rH   rl   rh   Úis_EqualityÚlhsÚrhsr   Ú	make_argsr   r”   Ú	is_NumberrM   Úseriesr   r   r   ÚOner   r^   Úhas_freer   rk   )Úexprsrn   r   Úindicesr   r   Úpolysr“   ÚpolyÚtermÚcoeffÚmonomr   ÚbaseÚexps                  r>   Ú _parallel_dict_from_expr_if_gensr§   È   s›  € ä�S—X‘X“ €wä˜#Ÿ(™(Ö#‰ˆØ�‹
ñ $ð €EäˆØˆà××Ø—8‘8˜dŸh™hÑ&ˆDä—M’M $Ö'ˆDØ ˜s 1™u�5äŸ-š-¨Ö-�Ü# 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™mÓ,ñ .ô* ˜%“LˆEà‹}Ø“œs E˜{Ñ*•ä! 5˜k�“ñ; (ð> 	�‰�T×ñK ðN —(‘(ˆ?Ðøô! $ó UØ%Ÿš°·±Ö9Ø!ŸL™L¨×0Ð0ä"1ð 3KØMSñ3Tó #Uð Uð	Uús   ÃAFÆ9G	ÇG	c                ó¦  ^• TR                   b  U4S jnO)TR                  SL a  S nOTR                  SLa  S nOS n[        5       / pCU  GHF  n/ nUR                  (       a  UR
                  UR                  -
  n[        R                  " U5       Hë  n/ 0 p˜[        R                  " U5       H¹  n
[        U
5      (       d1  U
R                  (       d  U" U
5      (       a  UR                  U
5        MD  TR                  SL a1  [        U
5      u  p¼US:  a  U* [        U[         R"                  * 5      p¼O[%        U
5      u  p¼U	R'                  US5      U-   X›'   UR)                  U5        M»     UR                  X‰45        Mí     UR                  U5        GMI     [+        UTS9n[-        U5      0 pí[/        U5       H
  u  nnXþU'   M     / nU Hx  n0 nU H\  u  p‡S/U-  nUR1                  5        H  u  p¼UUXë   '   M     [3        U5      nUU;   a  UU==   [        U6 -  ss'   MQ  [        U6 UU'   M^     UR                  U5        Mz     U[3        U5      4$ )	zITransform expressions into a multinomial form and figure out generators. c                ó"   >• U TR                   ;   $ r:   )Údomain)r   rn   s    €r>   Ú	_is_coeffÚ3_parallel_dict_from_expr_no_gens.<locals>._is_coeffþ   s   ø€ Ø˜SŸZ™ZÑ'Ð'rv   Tc                ó   • U R                   $ r:   )Úis_algebraic©r   s    r>   r«   r¬     s   € Ø×&Ñ&Ð&rv   Fc                ó&   • U [         R                  L $ r:   )r   ÚImaginaryUnitr¯   s    r>   r«   r¬     s   € ØœQŸ_™_Ð,Ð,rv   c                ó   • U R                   $ r:   r;   r¯   s    r>   r«   r¬     s   € Ø×#Ñ#Ð#rv   r   )rn   )rª   Ú	extensionÚgreedyÚsetr–   r—   r˜   r   r™   r   r”   rš   rM   r›   r   r   r   rœ   r   Ú
setdefaultÚaddro   rH   rh   Úitemsrk   )rž   rn   r«   rl   Úreprsr“   Útermsr¢   r£   Úelementsr   r¥   r¦   r   rŸ   r   r   r    r¡   r¤   s    `                  r>   Ú _parallel_dict_from_expr_no_gensr¼   û   s  ø€ à
‡z�zÑö	(à	�‰˜$Ò	ó	'à	�‰˜5Ò	 ó	-ò	$ô “%˜ˆ%äˆØˆà××Ø—8‘8˜dŸh™hÑ&ˆDä—M’M $Ö'ˆDØ  "�8äŸ-š-¨Ö-�Ü# F×+Ñ+°×1A×1AÁYÈv×EVÑEVØ—L‘L Ö(à—z‘z UÒ*Ü$3°FÓ$;™	˜à ›7Ø),¨¬c°$¼¿¹¸Ó.? øä$7¸Ó$?™	˜à%-×%8Ñ%8¸¸qÓ%AÀCÑ%G�H‘NØ—H‘H˜T–Nñ .ð �L‰L˜%Ð*Ö+ñ% (ð( 	�‰�U×ñ5 ô8 �d Ñ$€DÜ�T“˜B€wä˜$–‰ˆˆ1Ø�‹
ñ  ð €EãˆØˆã ‰KˆEØ�C˜‘EˆEà!ŸZ™Zž\‘	�Ø'*��g‘mÓ$ñ *ô ˜%“LˆEà˜‹}Ø�U“œs E˜{Ñ*•ä! 5˜k��U“ñ !ð 	�‰�TÖñ! ð$ ”%˜“+ÐÐrv   c                ó*   • [        U 4U5      u  u  p#X#4$ )zBTransform an expression into a multinomial form given generators. )r§   ©r“   rn   r¡   rl   s       r>   Ú_dict_from_expr_if_gensr¿   E  ó   € ä4°d°W¸cÓB�M�G€TØˆ:Ðrv   c                ó*   • [        U 4U5      u  u  p#X#4$ )zKTransform an expression into a multinomial form and figure out generators. )r¼   r¾   s       r>   Ú_dict_from_expr_no_gensrÂ   K  rÀ   rv   c                óJ   • [        U [        U5      5      u  p#X#R                  4$ )ú/Transform expressions into a multinomial form. )Ú_parallel_dict_from_exprr   rl   )rž   rm   Úrepsrn   s       r>   Úparallel_dict_from_exprrÇ   Q  s!   € ä(¨´¸dÓ0CÓD�I€DØ—‘ˆ>Ðrv   c                ó,  • UR                   SLa  U  Vs/ s H  o"R                  5       PM     n n[        S U  5       5      (       a  [        S5      eUR                  (       a  [	        X5      u  p4O[        X5      u  p4X1R                  SU05      4$ s  snf )rÄ   Fc              3  ó<   #   • U  H  oR                   S L v •  M     g7f)FN)Úis_commutative)r=   r“   s     r>   r?   Ú+_parallel_dict_from_expr.<locals>.<genexpr>\  s   é € Ð
:²E¨D×Ñ %Õ'²Eùs   ‚ú-non-commutative expressions are not supportedrl   )ÚexpandrJ   r   rl   r§   r¼   Úclone)rž   rn   r“   rÆ   rl   s        r>   rÅ   rÅ   W  s   € à
‡z�z˜ÒÙ,1Ó3ªE D—+‘+–-©EˆÐ3ä
Ñ
:±EÓ
:×:Ñ:ÜÐMÓNÐNà
‡x‡xÜ5°eÓA‰
ˆˆdä5°eÓA‰
ˆà—‘˜F D˜>Ó*Ð*Ð*ùò 4s   ”Bc                óJ   • [        U [        U5      5      u  p#X#R                  4$ )ú1Transform an expression into a multinomial form. )Ú_dict_from_exprr   rl   )r“   rm   Úreprn   s       r>   Údict_from_exprrÓ   g  s!   € ä˜t¤]°4Ó%8Ó9�H€CØ—‘ˆ=Ðrv   c                óâ  ^• U R                   SL a  [        S5      eS mUR                  SLGa  [        U [        [
        45      (       d  [        S5      eU R                  5       n [        U4S j[        R                  " U 5       5       5      (       a;  [        U 5      n [        U4S j[        R                  " U 5       5       5      (       a  M;  [        S [        R                  " U 5       5       5      (       a8  [        U 5      n [        S [        R                  " U 5       5       5      (       a  M8  UR                  (       a  [        X5      u  p#O[        X5      u  p#X!R                  SU05      4$ )rÐ   FrÌ   c                óÈ   • U R                   =(       aP    U R                  R                  =(       a3    U R                  R                  =(       a    U R                  R
                  $ r:   )Úis_Powr¦   Úis_positiveÚ
is_Integerr¥   Úis_Addr’   s    r>   Ú_is_expandable_powÚ+_dict_from_expr.<locals>._is_expandable_powr  sB   € Ø—‘÷ % §¡× 4Ñ 4÷ %¸¿¹×9LÑ9L÷ %Ø—I‘I×$Ñ$ð	&rv   zexpression must be of type Exprc              3  ó¦   >#   • U  HF  nT" U5      =(       d2    UR                   =(       a    [        U4S  jUR                   5       5      v •  MH     g7f)c              3  ó4   >#   • U  H  nT" U5      v •  M     g 7fr:   © )r=   r   rÚ   s     €r>   r?   Ú,_dict_from_expr.<locals>.<genexpr>.<genexpr>|  s   øé € Ð6ªv¨!Ñ" 1×%Ð%ªvùs   ƒN©Úis_MulrJ   rm   )r=   r   rÚ   s     €r>   r?   Ú"_dict_from_expr.<locals>.<genexpr>{  sG   øé € ð %â#ð <=ñ % QÓ'÷ 7¨1¯8©8÷ ,7ÜÔ6¨q¯vªvÓ6Ó6ô7â#ùs   ƒAAc              3  ó~   #   • U  H3  oR                   =(       a    [        S  UR                   5       5      v •  M5     g7f)c              3  ó8   #   • U  H  oR                   v •  M     g 7fr:   )rÙ   )r=   r   s     r>   r?   rß   €  s   é € Ð"<²V°§8¦8²VùrA   Nrà   )r=   r   s     r>   r?   râ   €  s+   é € ÐZÒFYÀ—(‘(×<œsÑ"<°Q·V²VÓ"<Ó<Ô<ÒFYùs   ‚;=rl   )rÊ   r   rÍ   r}   r
   r	   rJ   r   r™   r   r   rl   r¿   rÂ   rÎ   )r“   rn   rÒ   rl   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ÑZÜ˜dÓ#ˆDô ÑZÄcÇmÂmÐTXÔFYÓZ×ZÓZð ‡x‡xÜ+¨DÓ6‰	ˆˆTä+¨DÓ6‰	ˆà—	‘	˜6 4˜.Ó)Ð)Ð)rv   c                óê   • / nU R                  5        HV  u  p4U/n[        X5       H(  u  pgU(       d  M  UR                  [        Xg5      5        M*     UR                  [	        U6 5        MX     [        U6 $ )z/Convert a multinomial form into an expression. )r¸   rL   rM   r   r   r   )rÒ   rl   Úresultr¤   r£   r¢   r   r   s           r>   Úexpr_from_dictrç   ‹  sd   € à€FàŸ	™	ž‰ˆØˆwˆÜ˜Ö$‰DˆAßˆqØ—‘œC ›IÖ&ñ %ð 	�‰”c˜4�jÖ!ñ $ô �ˆ<Ðrv   c                óN  • [        U5      nU R                  5       nU R                  5       n[        [	        U 5      5       Vs/ s H  n/ PM     nn[        5       nU HM  n UR                  U5      n	UR                  U	5        [        X65       H  u  p«UR                  X©   5        M     MO     [        U5       H)  u  pÅXÇ;  d  M  U H  nXÜ   (       d  M  [        S5      e   M+     [        [        U5      U4$ s  snf ! [         a    U H  nUR                  S5        M      MÇ  f = f)z*Reorder levels using dict representation. r   zunable to drop generators)rN   ÚkeysÚvaluesÚrangerH   rµ   rX   r·   rL   rM   rY   rh   r   Úmaprk   )rÒ   rl   Únew_gensÚmonomsÚcoeffsrS   Ú
new_monomsÚused_indicesra   r   ÚMÚnew_Mr   r¤   s                 r>   Ú_dict_reorderrô   ž  s  € ä�‹:€Dà�X‰X‹Z€FØ�Z‰Z‹\€Fä$¤S¨£XœÓ0š˜!“2™€JÐ0Ü“5€Lãˆð	 Ø—
‘
˜3“ˆAØ×Ñ˜QÔä Ö3‘�Ø—‘˜Q™TÖ"ó 4ñ ô ˜$–‰ˆØÕ Û�Ø—8‘8Ü)Ð*EÓFÐFó  ñ  ô Œu�jÓ! 6Ð)Ð)ùò) 1øô ó 	 Û#�Ø—‘˜Q–ô $ð	 ús   ÁC7Á A	C<Ã<$D$Ä#D$c                  ó,   • \ rS rSrSrSrSS jrS rSrg)ÚPicklableWithSlotsi¼  a`  
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                ó2  • Uc  U R                   n0 nUR                   HC  n[        USS 5      n[        [        SS 5      nUc  M&  XELd  M,  UR	                  U" X5      5        ME     UR
                   H"  n[        X5      (       d  M  [        X5      X&'   M$     U$ )NÚ__getstate__)Ú	__class__Ú	__bases__ÚgetattrÚobjectÚupdateÚ	__slots__ry   )ÚselfÚclsr   r   ÚgetstateÚobjstaterb   s          r>   rø   ÚPicklableWithSlots.__getstate__ä  s�   € Ø‰;à—.‘.ˆCàˆð —”ˆAô ˜q .°$Ó7ˆHÜœv ~°tÓ<ˆHØÓ#¨Ô(@Ø—‘™ $Ó*Ö+ñ ð —M”MˆDÜ�t×"Ó"Ü! $Ó-�“ñ "ð ˆrv   c                óN   • UR                  5        H  u  p#[        XU5        M     g r:   )r¸   Úsetattr)rÿ   r   rb   Úvalues       r>   Ú__setstate__ÚPicklableWithSlots.__setstate__þ  s   € àŸ7™7ž9‰KˆDÜ�D Ö&ò %rv   r:   )	Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rþ   rø   r  Ú__static_attributes__rÞ   rv   r>   rö   rö   ¼  s   † ñ#ðJ €Iôõ4'rv   rö   c                  ó8   • \ rS rSrSrS	S jrS	S jrS rS rSr	g)
ÚIntegerPowerablei  a†  
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                óÒ  • US:  a<   US:X  a  U R                  5       $ US:X  a  U R                  5       $ U R                  XS9$ [        [        U5      SS  5       Vs/ s H  n[        U5      PM     nn[        U5      nU nSn[        U5       H;  nXH   (       a  U(       a  Un	SnOW	U-  n	Ub  X’-  n	X…S-
  :  d  M.  Xf-  nUc  M7  Xb-  nM=     W	$ ! [         a	    [        s $ f = fs  snf )NrB   rC   r   )ÚmoduloTF)
Ú_first_powerÚ_zeroth_powerÚ_negative_powerrG   ÚNotImplementedÚreversedÚbinr]   rH   rë   )
rÿ   r   r  r   Úbitsr    r"   Úfirstr   r/   s
             r>   Ú__pow__ÚIntegerPowerable.__pow__  s  € Øˆq‹5ð&Ø˜“6Ø×,Ñ,Ó.Ð.Ø˜!“VØ×-Ñ-Ó/Ð/à×/Ñ/°Ð/ÐAÐAô %-¬S°«V°A°B¨ZÔ$8Ó9Ò$8˜q”C˜–FÑ$8ˆDÐ9Ü�D“	ˆAØˆAØˆEÜ˜1–X�Ø—7ÞØ˜Ø %™à˜Q™˜Ø!Ñ-Ø™K˜AØ˜1‘u•9Ø‘F�AØÓ)Ø™šñ ð ˆHøô) 'ó &Ü%Ò%ð&üò :s!   ˆC žC ´C ÁC$ÃC!Ã C!c                ó   • [         e)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
©rG   )rÿ   r   r  s      r>   r  Ú IntegerPowerable._negative_power.  s
   € ô "Ð!rv   c                ó   • [         e)z?Return unity element of algebraic struct to which self belongs.r  ©rÿ   s    r>   r  ÚIntegerPowerable._zeroth_power6  ó   € ä!Ð!rv   c                ó   • [         e)zReturn a copy of self.r  r!  s    r>   r  ÚIntegerPowerable._first_power:  r#  rv   rÞ   r:   )
r	  r
  r  r  r  r  r  r  r  r  rÞ   rv   r>   r  r    s   † ñôô>"ò"õ"rv   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Ú	MULTILINErZ   rT   ro   ru   rz   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 '/Ó/¢h˜s‘�c–¡hÑ/€Ø" 1 Q™-Ó(š-�Q‰ˆaŽ™-Ñ(€òò0òfGòTòòò+ò ò*ò<ð 3Ð Ø €Ø €ò*÷<E'ñ E'÷P8"ñ 8"ðv Ó ð �7ÓÛØ—‘˜UŸ^™^Ð,�IåAØ€EØÐ!�Iùò[ 0ùÚ(s   Â9EÃE