Ë
    3^(h·“  ã                   ó˜  — d dl mZmZ d dlmZmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZ d dlZm[Z[ d dlZm\Z\ e]j¼                  Z_ G d„ de]«      Z` G d„ de`«      Zad	Zbd
ZcdZddec›ded›d�Zed3d„Zf efdddd«      ea_g         efddecz   decz   dedz   «      ea_h         efddecz   decz   dedz   «      ea_i         efddecz   decz   dedz   «      ea_j         efd d!ecz   d"ecz   d#edz   «      ea_k         efd$d%ecz   d&ecz   d'«      ea_l         efd(eed)ecz   d*edz   «      ea_m        eajÐ                  ea_n        eajÔ                  ea_o        eajÖ                  ea_p        eajâ                  ea_r         G d+„ d,ea«      Zs G d-„ d.e`«      ZteuetfZv G d/„ d0e]«      Zw	 d1d2lxZxexjò                  jõ                  et«       exjö                  jõ                  ea«       y2# e|$ r Y y2w xY w)4é   )Ú
basestringÚexec_)WÚMPZÚMPZ_ZEROÚMPZ_ONEÚ	int_typesÚrepr_dpsÚround_floorÚround_ceilingÚdps_to_precÚround_nearestÚprec_to_dpsÚComplexResultÚto_pickableÚfrom_pickableÚ	normalizeÚfrom_intÚ
from_floatÚfrom_npfloatÚfrom_DecimalÚfrom_strÚto_intÚto_floatÚto_strÚfrom_rationalÚfrom_man_expÚfoneÚfzeroÚfinfÚfninfÚfnanÚmpf_absÚmpf_posÚmpf_negÚmpf_addÚmpf_subÚmpf_mulÚmpf_mul_intÚmpf_divÚmpf_rdiv_intÚmpf_pow_intÚmpf_modÚmpf_eqÚmpf_cmpÚmpf_ltÚmpf_gtÚmpf_leÚmpf_geÚmpf_hashÚmpf_randÚmpf_sumÚbitcountÚto_fixedÚ
mpc_to_strÚmpc_to_complexÚmpc_hashÚmpc_posÚmpc_is_nonzeroÚmpc_negÚmpc_conjugateÚmpc_absÚmpc_addÚmpc_add_mpfÚmpc_subÚmpc_sub_mpfÚmpc_mulÚmpc_mul_mpfÚmpc_mul_intÚmpc_divÚmpc_div_mpfÚmpc_powÚmpc_pow_mpfÚmpc_pow_intÚmpc_mpf_divÚmpf_powÚmpf_piÚ
mpf_degreeÚmpf_eÚmpf_phiÚmpf_ln2Úmpf_ln10Ú	mpf_eulerÚmpf_catalanÚ	mpf_aperyÚmpf_khinchinÚmpf_glaisherÚmpf_twinprimeÚmpf_mertensr   )Úrational)Úfunction_docsc                   ó   — e Zd ZdZg Zd„ Zy)Ú	mpnumericzBase class for mpf and mpc.c                 ó   — t         ‚©N)ÚNotImplementedError)ÚclsÚvals     úR/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/mpmath/ctx_mp_python.pyÚ__new__zmpnumeric.__new__$   s   € Ü!Ð!ó    N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__re   © rf   rd   r^   r^   !   s   „ Ù%Ø€Ió"rf   r^   c                   óp  — e Zd ZdZdgZefd„Zed„ «       Zed„ «       Z	ed„ «       Z
 ed„ «      Z ed„ «      Z ed	„ «      Z ed
„ «      Z ed„ «      Z ed„ «      Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ ZeZd„ Zd„ Zd„ Z d„ Z!d„ Z"d„ Z#d„ Z$d„ Z%d „ Z&d!„ Z'd"„ Z(d#„ Z)d$„ Z*d%„ Z+d&„ Z,d+d(„Z-d)„ Z.d*„ Z/y'),Ú_mpfz¡
    An mpf instance holds a real-valued floating-point number. mpf:s
    work analogously to Python floats, but support arbitrary-precision
    arithmetic.
    Ú_mpf_c                 óÐ  — | j                   j                  \  }}|r6|j                  d|«      }d|v rt        |d   «      }|j                  d|«      }t	        |«      | u r9|j
                  \  }}}}|s|r|S t        | «      }	t        ||||||«      |	_        |	S t	        |«      t        u r�t        |«      dk(  r&t        | «      }	t        |d   |d   ||«      |	_        |	S t        |«      dk(  rG|t        t        t        fvr |\  }}}}t        |t        |«      ||||«      }t        | «      }	||	_        |	S t        ‚t        | «      }	t!        | j#                  |||«      ||«      |	_        |	S )z‹A new mpf can be created from a Python float, an int, a
        or a decimal string representing a number in floating-point
        format.ÚprecÚdpsÚroundingé   é    r   é   )ÚcontextÚ_prec_roundingÚgetr   Útypero   Únewr   ÚtupleÚlenr   r   r    r!   r   Ú
ValueErrorr#   Úmpf_convert_arg)
rb   rc   Úkwargsrq   rs   ÚsignÚmanÚexpÚbcÚvs
             rd   re   z_mpf.__new__/   sb  € ð Ÿ™×3Ñ3‰ˆˆhÙØ—:‘:˜f dÓ+ˆDØ˜‰Ü" 6¨%¡=Ó1�Ø—z‘z *¨hÓ7ˆHÜ�‹9˜ÑØ!$§¡ÑˆD�#�s˜BÙ™SØ�
Ü�C“ˆAÜ  c¨3°°D¸(ÓCˆAŒGØˆHÜ�#‹Yœ%ÑÜ�3‹x˜1Š}Ü˜“H�Ü& s¨1¡v¨s°1©v°t¸XÓF�”Ø�Ü�3‹x˜1Š}Øœt¤U¬DÐ1Ñ1Ø),Ñ&�D˜#˜s BÜ# D¬#¨c«(°C¸¸TÀ8ÓL�CÜ˜“H�Ø�”Ø�ÜÐä�C“ˆAÜ˜c×1Ñ1°#°t¸XÓFÈÈhÓWˆAŒGØˆHrf   c                 ób  — t        |t        «      rt        |«      S t        |t        «      rt	        |«      S t        |t
        «      rt        |||«      S t        || j                  j                  «      r|j                  ||«      S t        |d«      r|j                  S t        |d«      rC| j                  j                  |j                  ||«      «      }t        |d«      r|j                  S t        |d«      r!|j                  \  }}||k(  r|S t        d«      ‚t!        dt#        |«      z   «      ‚)Nro   Ú_mpmath_Ú_mpi_z,can only create mpf from zero-width intervalúcannot create mpf from )Ú
isinstancer   r   Úfloatr   r   r   rw   ÚconstantÚfuncÚhasattrro   Úconvertr‡   rˆ   r~   Ú	TypeErrorÚrepr)rb   Úxrq   rs   ÚtÚaÚbs          rd   r   z_mpf.mpf_convert_argR   sö   € ä�aœÔ#¬H°Q«KÐ%7Ü�aœÔ¬
°1«Ð!5Ü�aœÔ$¬X°a¸¸xÓ-HÐ&HÜ�a˜Ÿ™×-Ñ-Ô.°q·v±v¸dÀHÓ7MÐ0MÜ�1�gÔ q§w¡w Ü�1�jÔ!Ø—‘×#Ñ# A§J¡J¨t°XÓ$>Ó?ˆAÜ�q˜'Ô"Ø—w‘w�Ü�1�gÔØ—7‘7‰DˆAˆqØ�AŠvØ�ÜÐKÓLÐLÜÐ1´D¸³GÑ;Ó<Ð<rf   c                 óX  — t        |t        «      rt        |«      S t        |t        «      rt	        |«      S t        |t
        «      r| j                  j                  |«      S t        |t        j                  «      r0|j                  \  }}t        ||| j                  j                  «      S t        |d«      r|j                  S t        |d«      rV| j                  j                   |j                   | j                  j"                  Ž «      }t        |d«      r|j                  S |S t$        S )Nro   r‡   )rŠ   r   r   r‹   r   Úcomplex_typesrw   Úmpcr[   ÚmpqÚ_mpq_r   rq   rŽ   ro   r�   r‡   rx   ÚNotImplemented)rb   r’   ÚpÚqr“   s        rd   Úmpf_convert_rhsz_mpf.mpf_convert_rhsd   sÛ   € ä�aœÔ#¬H°Q«KÐ%7Ü�aœÔ¬
°1«Ð!5Ü�aœÔ'°·±·±ÀÓ0BÐ)BÜ�aœŸ™Ô&Ø—7‘7‰DˆAˆqÜ   A s§{¡{×'7Ñ'7Ó8Ð8Ü�1�gÔ q§w¡w Ü�1�jÔ!Ø—‘×#Ñ# J A§J¡J°·±×0JÑ0JÐ$KÓLˆAÜ�q˜'Ô"Ø—w‘w�ØˆHÜÐrf   c                 ó€   — | j                  |«      }t        |«      t        u r| j                  j	                  |«      S |S r`   )rž   rz   r|   rw   Úmake_mpf)rb   r’   s     rd   Úmpf_convert_lhsz_mpf.mpf_convert_lhst   s8   € à×Ñ Ó"ˆÜ�‹7”eÑØ—;‘;×'Ñ'¨Ó*Ð*Øˆrf   c                 ó    — | j                   dd S )Nr   é   ©ro   ©Úselfs    rd   ú<lambda>z_mpf.<lambda>{   s   €  D§J¡J¨q° O€ rf   c                 ó    — | j                   d   S ©Nr   r¤   r¥   s    rd   r§   z_mpf.<lambda>|   ó   €  §
¡
¨1¡€ rf   c                 ó    — | j                   d   S )Nrt   r¤   r¥   s    rd   r§   z_mpf.<lambda>}   rª   rf   c                 ó    — | j                   d   S )Nr£   r¤   r¥   s    rd   r§   z_mpf.<lambda>~   s   € ˜tŸz™z¨!™}€ rf   c                 ó   — | S r`   rl   r¥   s    rd   r§   z_mpf.<lambda>€   s   €  € rf   c                 ó.   — | j                   j                  S r`   )rw   Úzeror¥   s    rd   r§   z_mpf.<lambda>�   s   €  §¡×!2Ñ!2€ rf   c                 ó   — | S r`   rl   r¥   s    rd   r§   z_mpf.<lambda>ƒ   s   € ˜T€ rf   c                 ó,   — t        | j                  «      S r`   )r   ro   r¥   s    rd   Ú__getstate__z_mpf.__getstate__…   s   € ¤;¨t¯z©zÓ#:Ð:rf   c                 ó$   — t        |«      | _        y r`   )r   ro   ©r¦   rc   s     rd   Ú__setstate__z_mpf.__setstate__†   s   € ¬m¸CÓ.@ ¥rf   c                 óž   — | j                   j                  rt        | «      S dt        | j                  | j                   j
                  «      z  S )Nz	mpf('%s'))rw   ÚprettyÚstrr   ro   Ú_repr_digits©Úss    rd   Ú__repr__z_mpf.__repr__ˆ   s8   € Ø�9‰9×ÒÜ�q“6ˆMØœV A§G¡G¨Q¯Y©Y×-CÑ-CÓDÑDÐDrf   c                 óV   — t        | j                  | j                  j                  «      S r`   )r   ro   rw   Ú_str_digitsrº   s    rd   Ú__str__z_mpf.__str__�   s   € œ6 !§'¡'¨1¯9©9×+@Ñ+@ÓAÐArf   c                 ó,   — t        | j                  «      S r`   )r3   ro   rº   s    rd   Ú__hash__z_mpf.__hash__Ž   s   € œH Q§W¡WÓ-Ð-rf   c                 ó>   — t        t        | j                  «      «      S r`   )Úintr   ro   rº   s    rd   Ú__int__z_mpf.__int__�   s   € œ3œv a§g¡g›Ó/Ð/rf   c                 ó>   — t        t        | j                  «      «      S r`   )Úlongr   ro   rº   s    rd   Ú__long__z_mpf.__long__�   s   € œD¤¨¯©£Ó1Ð1rf   c                 ó^   — t        | j                  | j                  j                  d   ¬«      S ©Nr   )Úrnd)r   ro   rw   rx   rº   s    rd   Ú	__float__z_mpf.__float__‘   s!   € œX a§g¡g°1·9±9×3KÑ3KÈAÑ3NÔOÐOrf   c                 ó*   — t        t        | «      «      S r`   )Úcomplexr‹   rº   s    rd   Ú__complex__z_mpf.__complex__’   s   € œw¤u¨Q£xÓ0Ð0rf   c                 ó(   — | j                   t        k7  S r`   )ro   r   rº   s    rd   Ú__nonzero__z_mpf.__nonzero__“   s   € ˜qŸw™w¬%Ñ/Ð/rf   c                 ót   — | j                   \  }}\  }} ||«      }t        | j                  ||«      |_        |S r`   )Ú_ctxdatar"   ro   ©r»   rb   r{   rq   rs   r…   s         rd   Ú__abs__z_mpf.__abs__—   ó9   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ù�‹HˆÜ˜!Ÿ'™' 4¨Ó2ˆŒØˆrf   c                 ót   — | j                   \  }}\  }} ||«      }t        | j                  ||«      |_        |S r`   )rÒ   r#   ro   rÓ   s         rd   Ú__pos__z_mpf.__pos__�   rÕ   rf   c                 ót   — | j                   \  }}\  }} ||«      }t        | j                  ||«      |_        |S r`   )rÒ   r$   ro   rÓ   s         rd   Ú__neg__z_mpf.__neg__£   rÕ   rf   c                 ó�   — t        |d«      r|j                  }n| j                  |«      }|t        u r|S  || j                  |«      S ©Nro   )rŽ   ro   rž   r›   )r»   r“   r�   s      rd   Ú_cmpz	_mpf._cmp©   sC   € Ü�1�gÔØ—‘‰Aà×!Ñ! !Ó$ˆAØ”NÑ"Ø�Ù�A—G‘G˜QÓÐrf   c                 ó.   — | j                  |t        «      S r`   )rÜ   r.   ©r»   r“   s     rd   Ú__cmp__z_mpf.__cmp__²   s   € ˜aŸf™f Q¬Ó0Ð0rf   c                 ó.   — | j                  |t        «      S r`   )rÜ   r/   rÞ   s     rd   Ú__lt__z_mpf.__lt__³   ó   € ˜QŸV™V A¤vÓ.Ð.rf   c                 ó.   — | j                  |t        «      S r`   )rÜ   r0   rÞ   s     rd   Ú__gt__z_mpf.__gt__´   râ   rf   c                 ó.   — | j                  |t        «      S r`   )rÜ   r1   rÞ   s     rd   Ú__le__z_mpf.__le__µ   râ   rf   c                 ó.   — | j                  |t        «      S r`   )rÜ   r2   rÞ   s     rd   Ú__ge__z_mpf.__ge__¶   râ   rf   c                 ó>   — | j                  |«      }|t        u r|S | S r`   ©Ú__eq__r›   )r»   r“   r…   s      rd   Ú__ne__z_mpf.__ne__¸   ó#   € Ø�H‰H�Q‹KˆØ”ÑØˆHØˆuˆrf   c                 óê   — | j                   \  }}\  }}t        |«      t        v r0 ||«      }t        t	        |«      | j
                  ||«      |_        |S | j                  |«      }|t        u r|S || z
  S r`   )rÒ   rz   r   r&   r   ro   r¡   r›   ©r»   r“   rb   r{   rq   rs   r…   s          rd   Ú__rsub__z_mpf.__rsub__¾   sq   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ü�‹7”iÑÙ�C“ˆAÜœh q›k¨1¯7©7°D¸(ÓCˆAŒGØˆHØ×Ñ˜aÓ ˆØ”ÑØˆHØ�1‰uˆrf   c                 óÖ   — | j                   \  }}\  }}t        |t        «      r' ||«      }t        || j                  ||«      |_        |S | j                  |«      }|t        u r|S || z  S r`   )rÒ   rŠ   r   r*   ro   r¡   r›   rï   s          rd   Ú__rdiv__z_mpf.__rdiv__É   sk   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ü�aœÔ#Ù�C“ˆAÜ" 1 a§g¡g¨t°XÓ>ˆAŒGØˆHØ×Ñ˜aÓ ˆØ”ÑØˆHØ�1‰uˆrf   c                 óB   — | j                  |«      }|t        u r|S || z  S r`   ©r¡   r›   rÞ   s     rd   Ú__rpow__z_mpf.__rpow__Ô   ó(   € Ø×Ñ˜aÓ ˆØ”ÑØˆHØ�A‰vˆrf   c                 óB   — | j                  |«      }|t        u r|S || z  S r`   rô   rÞ   s     rd   Ú__rmod__z_mpf.__rmod__Ú   ó(   € Ø×Ñ˜aÓ ˆØ”ÑØˆHØ�1‰uˆrf   c                 ó8   — | j                   j                  | «      S r`   )rw   Úsqrtrº   s    rd   rû   z	_mpf.sqrtà   s   € Ø�y‰y�~‰~˜aÓ Ð rf   Nc                 ó>   — | j                   j                  | |||«      S r`   ©rw   Úalmosteq©r»   r“   Úrel_epsÚabs_epss       rd   Úaez_mpf.aeã   ó   € Ø�y‰y×!Ñ! ! Q¨°Ó9Ð9rf   c                 ó.   — t        | j                  |«      S r`   )r7   ro   )r¦   rq   s     rd   r7   z_mpf.to_fixedæ   s   € Ü˜Ÿ
™
 DÓ)Ð)rf   c                 ó,   — t        t        | «      g|¢­Ž S r`   )Úroundr‹   )r¦   Úargss     rd   Ú	__round__z_mpf.__round__é   s   € Ü”U˜4“[Ð( 4Ò(Ð(rf   ©NN)0rg   rh   ri   rj   rk   r   re   Úclassmethodr   rž   r¡   ÚpropertyÚman_expr‚   rƒ   r„   ÚrealÚimagÚ	conjugater²   rµ   r¼   r¿   rÁ   rÄ   rÇ   rË   rÎ   rÐ   Ú__bool__rÔ   r×   rÙ   rÜ   rß   rá   rä   ræ   rè   rì   rð   rò   rõ   rø   rû   r  r7   r  rl   rf   rd   rn   rn   '   s  „ ñð
 �	€Iàó !ðF ñ=ó ð=ð" ñó ðð ñó ðñ Ñ3Ó4€GÙ
Ñ-Ó
.€CÙ
Ñ-Ó
.€CÙ	Ñ,Ó	-€BáÑ%Ó&€DÙÑ2Ó3€Dá!€Iâ:Ú@òEò
 BÚ-Ú/Ú1ÚOÚ0Ú/à€Hòòòò ò 1Ú.Ú.Ú.Ú.òò	ò	òòò!ó:ò*ó)rf   rn   a  
def %NAME%(self, other):
    mpf, new, (prec, rounding) = self._ctxdata
    sval = self._mpf_
    if hasattr(other, '_mpf_'):
        tval = other._mpf_
        %WITH_MPF%
    ttype = type(other)
    if ttype in int_types:
        %WITH_INT%
    elif ttype is float:
        tval = from_float(other)
        %WITH_MPF%
    elif hasattr(other, '_mpc_'):
        tval = other._mpc_
        mpc = type(other)
        %WITH_MPC%
    elif ttype is complex:
        tval = from_float(other.real), from_float(other.imag)
        mpc = self.context.mpc
        %WITH_MPC%
    if isinstance(other, mpnumeric):
        return NotImplemented
    try:
        other = mpf.context.convert(other, strings=False)
    except TypeError:
        return NotImplemented
    return self.%NAME%(other)
z-; obj = new(mpf); obj._mpf_ = val; return objz-; obj = new(mpc); obj._mpc_ = val; return objzD
        try:
            val = mpf_pow(sval, tval, prec, rounding) zÈ
        except ComplexResult:
            if mpf.context.trap_complex:
                raise
            mpc = mpf.context.mpc
            val = mpc_pow((sval, fzero), (tval, fzero), prec, rounding) ú
c                 óÖ   — t         }|j                  d|«      }|j                  d|«      }|j                  d|«      }|j                  d| «      }i }t        |t        «       |«       ||    S )Nz
%WITH_INT%z
%WITH_MPC%z
%WITH_MPF%z%NAME%)Úmpf_binary_opÚreplacer   Úglobals)ÚnameÚwith_mpfÚwith_intÚwith_mpcÚcodeÚnps         rd   Ú	binary_opr    sc   € Ü€DØ�<‰<˜ hÓ/€DØ�<‰<˜ hÓ/€DØ�<‰<˜ hÓ/€DØ�<‰<˜ $Ó'€DØ	€BÜ	ˆ$”“	˜2ÔØˆd‰8€Orf   rë   zreturn mpf_eq(sval, tval)z$return mpf_eq(sval, from_int(other))z3return (tval[1] == fzero) and mpf_eq(tval[0], sval)Ú__add__z)val = mpf_add(sval, tval, prec, rounding)z4val = mpf_add(sval, from_int(other), prec, rounding)z-val = mpc_add_mpf(tval, sval, prec, rounding)Ú__sub__z)val = mpf_sub(sval, tval, prec, rounding)z4val = mpf_sub(sval, from_int(other), prec, rounding)z2val = mpc_sub((sval, fzero), tval, prec, rounding)Ú__mul__z)val = mpf_mul(sval, tval, prec, rounding)z.val = mpf_mul_int(sval, other, prec, rounding)z-val = mpc_mul_mpf(tval, sval, prec, rounding)Ú__div__z)val = mpf_div(sval, tval, prec, rounding)z4val = mpf_div(sval, from_int(other), prec, rounding)z-val = mpc_mpf_div(sval, tval, prec, rounding)Ú__mod__z)val = mpf_mod(sval, tval, prec, rounding)z4val = mpf_mod(sval, from_int(other), prec, rounding)z+raise NotImplementedError("complex modulo")Ú__pow__z.val = mpf_pow_int(sval, other, prec, rounding)z2val = mpc_pow((sval, fzero), tval, prec, rounding)c                   ó6   — e Zd ZdZdd„Zdd„Zed„ «       Zd„ Zy)	Ú	_constantzõRepresents a mathematical constant with dynamic precision.
    When printed or used in an arithmetic operation, a constant
    is converted to a regular mpf at the working precision. A
    regular mpf can also be obtained using the operation +x.c                 óx   — t         j                  | «      }||_        ||_        t	        t
        |d«      |_        |S )NÚ )Úobjectre   r  r�   Úgetattrr\   rj   )rb   r�   r  Údocnamer”   s        rd   re   z_constant.__new__P  s3   € Ü�N‰N˜3ÓˆØˆŒØˆŒÜœM¨7°BÓ7ˆŒ	Øˆrf   Nc                 ó´   — | j                   j                  \  }}|s|}|s|}|rt        |«      }| j                   j                  | j	                  ||«      «      S r`   )rw   rx   r   r    r�   )r¦   rq   rr   rs   Úprec2Ú	rounding2s         rd   Ú__call__z_constant.__call__W  sP   € ØŸ<™<×6Ñ6ÑˆˆyÙ˜E�TÙ I˜Ù”{ 3Ó'�Ø�|‰|×$Ñ$ T§Y¡Y¨t°XÓ%>Ó?Ð?rf   c                 óX   — | j                   j                  \  }}| j                  ||«      S r`   )rw   rx   r�   )r¦   rq   rs   s      rd   ro   z_constant._mpf_^  s&   € àŸ™×4Ñ4‰ˆˆhØ�y‰y˜˜xÓ(Ð(rf   c                 óh   — d| j                   ›d| j                  j                   | d¬«      «      ›d�S )Nú<z: é   )rr   z~>)r  rw   Únstrr¥   s    rd   r¼   z_constant.__repr__c  s$   � Ø"Ÿi›i¨¯©×):Ñ):¹4ÀB¼<Õ)HÐIÐIrf   )r&  )NNN)	rg   rh   ri   rj   re   r-  r  ro   r¼   rl   rf   rd   r$  r$  J  s-   „ ñ@ó
ó@ð ñ)ó ð)óJrf   r$  c                   ó  — e Zd ZdZdgZd d„Z ed„ «      Z ed„ «      Zd„ Z	d„ Z
d„ Zd	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ ZeZd„ Zed„ «       Zd„ Zd„ Zd„ ZeZeZeZeZd„ Zd„ Zd„ Zd„ Z d„ Z!eZ"d„ Z#d„ Z$d„ Z%d„ Z&e Z'e%Z(d!d„Z)y)"Ú_mpczÇ
    An mpc represents a complex number using a pair of mpf:s (one
    for the real part and another for the imaginary part.) The mpc
    class behaves fairly similarly to Python's complex type.
    Ú_mpc_c                 óf  — t         j                  | «      }t        |t        «      r|j                  |j
                  }}nt        |d«      r|j                  |_        |S | j                  j                  |«      }| j                  j                  |«      }|j                  |j                  f|_        |S )Nr5  )r'  re   rŠ   r—   r  r  rŽ   r5  rw   Úmpfro   )rb   r  r  r»   s       rd   re   z_mpc.__new__p  s‚   € Ü�N‰N˜3ÓˆÜ�dœMÔ*ØŸ™ D§I¡I�$‰DÜ�T˜7Ô#Ø—j‘jˆAŒGØˆHØ�{‰{�‰˜tÓ$ˆØ�{‰{�‰˜tÓ$ˆØ—:‘:˜tŸz™zÐ*ˆŒØˆrf   c                 óR   — | j                   j                  | j                  d   «      S )Nru   ©rw   r    r5  r¥   s    rd   r§   z_mpc.<lambda>|  ó   €  §¡×!6Ñ!6°t·z±zÀ!±}Ó!E€ rf   c                 óR   — | j                   j                  | j                  d   «      S r©   r9  r¥   s    rd   r§   z_mpc.<lambda>}  r:  rf   c                 ób   — t        | j                  d   «      t        | j                  d   «      fS ©Nru   r   )r   r5  r¥   s    rd   r²   z_mpc.__getstate__  s'   € Ü˜4Ÿ:™: a™=Ó)¬;°t·z±zÀ!±}Ó+EÐEÐErf   c                 óF   — t        |d   «      t        |d   «      f| _        y r=  )r   r5  r´   s     rd   rµ   z_mpc.__setstate__‚  s    € Ü" 3 q¡6Ó*¬M¸#¸a¹&Ó,AÐAˆ�
rf   c                 óà   — | j                   j                  rt        | «      S t        | j                  «      dd }t        | j
                  «      dd }t        | «      j                  ›d|›d|›d�S )Nrv   éÿÿÿÿz(real=z, imag=ú))rw   r·   r¸   r‘   r  r  rz   rg   )r»   ÚrÚis      rd   r¼   z_mpc.__repr__…  sW   € Ø�9‰9×ÒÜ�q“6ˆMÜ�—‘‹L˜˜2ÐˆÜ�—‘‹L˜˜2ÐˆÜ)-¨a«×)9Ó)9º1ºaÐ@Ð@rf   c                 ó\   — dt        | j                  | j                  j                  «      z  S )Nz(%s))r8   r5  rw   r¾   rº   s    rd   r¿   z_mpc.__str__Œ  s"   € Øœ
 1§7¡7¨A¯I©I×,AÑ,AÓBÑBÐBrf   c                 ó^   — t        | j                  | j                  j                  d   ¬«      S rÉ   )r9   r5  rw   rx   rº   s    rd   rÎ   z_mpc.__complex__�  s"   € Ü˜aŸg™g¨1¯9©9×+CÑ+CÀAÑ+FÔGÐGrf   c                 ót   — | j                   \  }}\  }} ||«      }t        | j                  ||«      |_        |S r`   )rÒ   r;   r5  rÓ   s         rd   r×   z_mpc.__pos__’  rÕ   rf   c                 ó®   — | j                   j                  \  }}t        | j                   j                  «      }t	        | j
                  ||«      |_        |S r`   )rw   rx   r{   r7  r?   r5  ro   )r»   rq   rs   r…   s       rd   rÔ   z_mpc.__abs__˜  s@   € ØŸ™×1Ñ1‰ˆˆhÜ�—	‘	—‘ÓˆÜ˜!Ÿ'™' 4¨Ó2ˆŒØˆrf   c                 ót   — | j                   \  }}\  }} ||«      }t        | j                  ||«      |_        |S r`   )rÒ   r=   r5  rÓ   s         rd   rÙ   z_mpc.__neg__ž  rÕ   rf   c                 ót   — | j                   \  }}\  }} ||«      }t        | j                  ||«      |_        |S r`   )rÒ   r>   r5  rÓ   s         rd   r  z_mpc.conjugate¤  s9   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ù�‹HˆÜ §¡¨¨xÓ8ˆŒØˆrf   c                 ó,   — t        | j                  «      S r`   )r<   r5  rº   s    rd   rÐ   z_mpc.__nonzero__ª  s   € Ü˜aŸg™gÓ&Ð&rf   c                 ó,   — t        | j                  «      S r`   )r:   r5  rº   s    rd   rÁ   z_mpc.__hash__¯  s   € Ü˜Ÿ™Ó Ð rf   c                 óh   — 	 | j                   j                  |«      }|S # t        $ r	 t        cY S w xY wr`   )rw   r�   r�   r›   )rb   r’   Úys      rd   Úmpc_convert_lhsz_mpc.mpc_convert_lhs²  s5   € ð	"Ø—‘×#Ñ# AÓ&ˆAØˆHøÜò 	"Ü!Ò!ð	"ús   ‚ Ÿ1°1c                 óÚ   — t        |d«      s,t        |t        «      ry| j                  |«      }|t        u r|S | j
                  |j
                  k(  xr | j                  |j                  k(  S )Nr5  F)rŽ   rŠ   r¸   rN  r›   r  r  rÞ   s     rd   rë   z_mpc.__eq__º  s[   € Ü�q˜'Ô"Ü˜!œSÔ!ØØ×!Ñ! !Ó$ˆAØ”NÑ"Ø�Ø�v‰v˜Ÿ™ÑÒ4 A§F¡F¨a¯f©fÑ$4Ð4rf   c                 ó>   — | j                  |«      }|t        u r|S | S r`   rê   )r»   r“   r•   s      rd   rì   z_mpc.__ne__Ã  rí   rf   c                  ó   — t        d«      ‚)Nz3no ordering relation is defined for complex numbers)r�   )r  s    rd   Ú_comparez_mpc._compareÉ  s   € ÜÐMÓNÐNrf   c                 óR  — | j                   \  }}\  }}t        |d«      sX| j                  |«      }|t        u r|S t        |d«      r1 ||«      }t	        | j
                  |j                  ||«      |_        |S  ||«      }t        | j
                  |j
                  ||«      |_        |S ©Nr5  ro   )rÒ   rŽ   rN  r›   rA   r5  ro   r@   rï   s          rd   r  z_mpc.__add__Ñ  ó˜   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ü�q˜'Ô"Ø×!Ñ! !Ó$ˆAØ”NÑ"Ø�Ü�q˜'Ô"Ù˜“H�Ü% a§g¡g¨q¯w©w¸¸hÓG�”Ø�Ù�‹HˆÜ˜!Ÿ'™' 1§7¡7¨D°(Ó;ˆŒØˆrf   c                 óR  — | j                   \  }}\  }}t        |d«      sX| j                  |«      }|t        u r|S t        |d«      r1 ||«      }t	        | j
                  |j                  ||«      |_        |S  ||«      }t        | j
                  |j
                  ||«      |_        |S rT  )rÒ   rŽ   rN  r›   rC   r5  ro   rB   rï   s          rd   r  z_mpc.__sub__ß  rU  rf   c                 óâ  — | j                   \  }}\  }}t        |d«      s t        |t        «      r' ||«      }t	        | j
                  |||«      |_        |S | j                  |«      }|t        u r|S t        |d«      r1 ||«      }t        | j
                  |j                  ||«      |_        |S | j                  |«      } ||«      }t        | j
                  |j
                  ||«      |_        |S rT  )rÒ   rŽ   rŠ   r   rF   r5  rN  r›   rE   ro   rD   rï   s          rd   r  z_mpc.__mul__í  sÖ   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ü�q˜'Ô"Ü˜!œYÔ'Ù˜“H�Ü% a§g¡g¨q°$¸ÓA�”Ø�Ø×!Ñ! !Ó$ˆAØ”NÑ"Ø�Ü�q˜'Ô"Ù˜“H�Ü% a§g¡g¨q¯w©w¸¸hÓG�”Ø�Ø×!Ñ! !Ó$ˆAÙ�‹HˆÜ˜!Ÿ'™' 1§7¡7¨D°(Ó;ˆŒØˆrf   c                 óR  — | j                   \  }}\  }}t        |d«      sX| j                  |«      }|t        u r|S t        |d«      r1 ||«      }t	        | j
                  |j                  ||«      |_        |S  ||«      }t        | j
                  |j
                  ||«      |_        |S rT  )rÒ   rŽ   rN  r›   rH   r5  ro   rG   rï   s          rd   r   z_mpc.__div__   rU  rf   c                 ó˜  — | j                   \  }}\  }}t        |t        «      r' ||«      }t        | j                  |||«      |_        |S | j                  |«      }|t        u r|S  ||«      }t        |d«      r)t        | j                  |j                  ||«      |_        |S t        | j                  |j                  ||«      |_        |S rÛ   )rÒ   rŠ   r   rK   r5  rN  r›   rŽ   rJ   ro   rI   rï   s          rd   r"  z_mpc.__pow__  s·   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ü�aœÔ#Ù�C“ˆAÜ! !§'¡'¨1¨d°HÓ=ˆAŒGØˆHØ×Ñ˜aÓ ˆØ”ÑØˆHÙ�‹HˆÜ�1�gÔÜ! !§'¡'¨1¯7©7°D¸(ÓCˆAŒGð ˆô ˜aŸg™g q§w¡w°°hÓ?ˆAŒGØˆrf   c                 óB   — | j                  |«      }|t        u r|S || z
  S r`   ©rN  r›   rÞ   s     rd   rð   z_mpc.__rsub__   rù   rf   c                 óÖ   — | j                   \  }}\  }}t        |t        «      r' ||«      }t        | j                  |||«      |_        |S | j                  |«      }|t        u r|S || z  S r`   )rÒ   rŠ   r   rF   r5  rN  r›   rï   s          rd   Ú__rmul__z_mpc.__rmul__&  sk   € Ø%&§Z¡ZÑ"ˆˆSÑ"�4˜Ü�aœÔ#Ù�C“ˆAÜ! !§'¡'¨1¨d°HÓ=ˆAŒGØˆHØ×Ñ˜aÓ ˆØ”ÑØˆHØ�1‰uˆrf   c                 óB   — | j                  |«      }|t        u r|S || z  S r`   r[  rÞ   s     rd   rò   z_mpc.__rdiv__1  rù   rf   c                 óB   — | j                  |«      }|t        u r|S || z  S r`   r[  rÞ   s     rd   rõ   z_mpc.__rpow__7  rö   rf   Nc                 ó>   — | j                   j                  | |||«      S r`   rý   rÿ   s       rd   r  z_mpc.ae@  r  rf   )ru   ru   r	  )*rg   rh   ri   rj   rk   re   r  r  r  r²   rµ   r¼   r¿   rÎ   r×   rÔ   rÙ   r  rÐ   r  rÁ   r
  rN  rë   rì   rR  rä   ræ   rè   r  r  r  r   r"  Ú__radd__rð   r]  rò   rõ   Ú__truediv__Ú__rtruediv__r  rl   rf   rd   r4  r4  g  sï   „ ñð �	€Ió
ñ ÑEÓF€DÙÑEÓF€DòFòBòAòCòHòòòòò'ð €Hò!ð ñ"ó ð"ò5òòOð €FØ€FØ€FØ€Fòòòò&òð  €Hòò	òòð €KØ€Lô:rf   r4  c                   óº   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z e	d„ e«      Z
 e	d„ e«      Zdd	„Zd
„ Zd„ Zd„ Zd„ Zdd„Zdd„Zdd„Zdd„Zed„ «       Zd„ Zd„ Zd„ Zy)ÚPythonMPContextc                 ó  — dt         g| _        t        dt        fi «      | _        t        dt
        fi «      | _        | j                  t        | j                  g| j                  _        | j                  t        | j                  g| j                  _        | | j                  _	        | | j                  _	        t        dt        fi «      | _        | j                  t        | j                  g| j                  _        | | j                  _	        y )Né5   r7  r˜   rŒ   )r   rx   rz   rn   r7  r4  r˜   r{   rÒ   rw   r$  rŒ   ©Úctxs    rd   Ú__init__zPythonMPContext.__init__I  s¾   € Ø ¤-Ð0ˆÔÜ�uœt˜g rÓ*ˆŒÜ�uœt˜g rÓ*ˆŒØŸG™G¤S¨#×*<Ñ*<Ð=ˆ�‰ÔØŸG™G¤S¨#×*<Ñ*<Ð=ˆ�‰ÔØˆ�‰ŒØˆ�‰ŒÜ˜J¬¨°bÓ9ˆŒØ!$§¡¬#¨s×/AÑ/AÐ Bˆ�‰ÔØ"ˆ�‰Õrf   c                 ó>   — t        | j                  «      }||_        |S r`   )r{   r7  ro   ©ri  r…   r”   s      rd   r    zPythonMPContext.make_mpfU  ó   € Ü�—‘‹LˆØˆŒØˆrf   c                 ó>   — t        | j                  «      }||_        |S r`   )r{   r˜   r5  rl  s      rd   Úmake_mpczPythonMPContext.make_mpcZ  rm  rf   c                 óL   — dx| _         | j                  d<   d| _        d| _        y )Nrg  ru   r1  F)Ú_precrx   Ú_dpsÚtrap_complexrh  s    rd   ÚdefaultzPythonMPContext.default_  s(   € Ø,.Ð.ˆŒ	�C×&Ñ& qÑ)ØˆŒØ ˆÕrf   c                 óv   — t        dt        |«      «      x| _        | j                  d<   t	        |«      | _        y )Nr   ru   )ÚmaxrÃ   rq  rx   r   rr  ©ri  Úns     rd   Ú	_set_preczPythonMPContext._set_precd  s.   € Ü,/°´3°q³6«NÐ:ˆŒ	�C×&Ñ& qÑ)Ü˜q“>ˆ�rf   c                 óv   — t        |«      x| _        | j                  d<   t        dt	        |«      «      | _        y r=  )r   rq  rx   rv  rÃ   rr  rw  s     rd   Ú_set_dpszPythonMPContext._set_dpsh  s.   € Ü,7¸«NÐ:ˆŒ	�C×&Ñ& qÑ)Ü�qœ#˜a›&“>ˆ�rf   c                 ó   — | j                   S r`   )rq  rh  s    rd   r§   zPythonMPContext.<lambda>l  s
   €  §	¡	€ rf   c                 ó   — | j                   S r`   )rr  rh  s    rd   r§   zPythonMPContext.<lambda>m  s
   € ˜sŸx™x€ rf   c                 ó4  — t        |«      | j                  v r|S t        |t        «      r| j	                  t        |«      «      S t        |t        «      r| j	                  t        |«      «      S t        |t        «      r9| j                  t        |j                  «      t        |j                  «      f«      S t        |«      j                  dk(  r| j                  |«      S t        |t        j                  «      r<t!        j"                  t%        |j&                  «      t%        |j(                  «      «      }| j*                  \  }}t        |t         j"                  «      r+|j,                  \  }}| j	                  t/        |||«      «      S |r/t        |t0        «      r	 t3        |||«      }| j	                  |«      S t7        |d«      r| j	                  |j8                  «      S t7        |d«      r| j                  |j:                  «      S t7        |d«      r!| j=                  |j?                  ||«      «      S t        |«      j                  dk(  r| j	                  tA        |||«      «      S | jC                  ||«      S #  Y �ŒKxY w# t4        $ r Y ŒÔw xY w#  Y Œ-xY w)a»  
        Converts *x* to an ``mpf`` or ``mpc``. If *x* is of type ``mpf``,
        ``mpc``, ``int``, ``float``, ``complex``, the conversion
        will be performed losslessly.

        If *x* is a string, the result will be rounded to the present
        working precision. Strings representing fractions or complex
        numbers are permitted.

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> mpmathify(3.5)
            mpf('3.5')
            >>> mpmathify('2.1')
            mpf('2.1000000000000001')
            >>> mpmathify('3/4')
            mpf('0.75')
            >>> mpmathify('2+3j')
            mpc(real='2.0', imag='3.0')

        Únumpyro   r5  r‡   Údecimal)"rz   ÚtypesrŠ   r   r    r   r‹   r   rÍ   ro  r  r  rh   Ú	npconvertÚnumbersÚRationalr[   r™   rÃ   Ú	numeratorÚdenominatorrx   rš   r   r   r   r~   rŽ   ro   r5  r�   r‡   r   Ú_convert_fallback)ri  r’   Ústringsrq   rs   rœ   r�   ro   s           rd   r�   zPythonMPContext.converto  s  € ô, �‹7�c—i‘iÑ¨ Ü�aœÔ#¨C¯L©L¼À!»Ó,EÐ%EÜ�aœÔ¨¯©´ZÀ³]Ó(CÐ!CÜ�aœÔ!Ø—<‘<¤¨A¯F©FÓ!3´ZÀÇÁÓ5GÐ HÓIÐIÜ�‹7×Ñ Ò(°·±¸qÓ1AÐ*AÜ�aœ×)Ñ)Ô*Ü—\‘\¤# a§k¡kÓ"2´C¸¿¹Ó4FÓG�à×+Ñ+‰ˆˆhÜ�aœŸ™Ô&Ø—7‘7‰DˆAˆqØ—<‘<¤¨a°°DÓ 9Ó:Ð:Ù”z !¤ZÔ0ðÜ   D¨(Ó3�Ø—|‘| EÓ*Ð*ô �1�gÔ s§|¡|°A·G±GÓ'<Ð <Ü�1�gÔ s§|¡|°A·G±GÓ'<Ð <Ü�1�jÔ!Ø—;‘;˜qŸz™z¨$°Ó9Ó:Ð:Ü�‹7×Ñ Ò*ØŸ™¤\°!°T¸8Ó%DÓEÐEà×$Ñ$ Q¨Ó0Ð0øð% ’Dûô ò Ùðûð ‘Dús*   Ã:<I< ÆJ ÉJ É<JÊ	JÊJÊJc                 ó¨  — ddl }t        ||j                  «      r#| j                  t	        t        |«      «      «      S t        ||j                  «      r| j                  t        |«      «      S t        ||j                  «      r9| j                  t        |j                  «      t        |j                  «      f«      S t        dt        |«      z   «      ‚)z^
        Converts *x* to an ``mpf`` or ``mpc``. *x* should be a numpy
        scalar.
        ru   Nr‰   )r  rŠ   Úintegerr    r   rÃ   Úfloatingr   Úcomplexfloatingro  r  r  r�   r‘   )ri  r’   r  s      rd   r‚  zPythonMPContext.npconvert¡  s—   € ó
 	Ü�a˜Ÿ™Ô$¨S¯\©\¼(Ä3ÀqÃ6Ó:JÓ-KÐ&KÜ�a˜Ÿ™Ô%¨c¯l©l¼<È»?Ó.KÐ'KÜ�a˜×+Ñ+Ô,Ø—<‘<¤¨a¯f©fÓ!5´|ÀAÇFÁFÓ7KÐ LÓMÐMÜÐ1´D¸³GÑ;Ó<Ð<rf   c                 ó\  — t        |d«      r|j                  t        k(  S t        |d«      rt        |j                  v S t	        |t
        «      st	        |t        j                  «      ry| j                  |«      }t        |d«      st        |d«      r| j                  |«      S t        d«      ‚)a¢  
        Return *True* if *x* is a NaN (not-a-number), or for a complex
        number, whether either the real or complex part is NaN;
        otherwise return *False*::

            >>> from mpmath import *
            >>> isnan(3.14)
            False
            >>> isnan(nan)
            True
            >>> isnan(mpc(3.14,2.72))
            False
            >>> isnan(mpc(3.14,nan))
            True

        ro   r5  Fzisnan() needs a number as input)rŽ   ro   r!   r5  rŠ   r   r[   r™   r�   Úisnanr�   )ri  r’   s     rd   rŽ  zPythonMPContext.isnan­  sˆ   € ô" �1�gÔØ—7‘7œd‘?Ð"Ü�1�gÔÜ˜1Ÿ7™7�?Ð"Ü�aœÔ#¤z°!´X·\±\Ô'BØØ�K‰K˜‹NˆÜ�1�gÔ¤'¨!¨WÔ"5Ø—9‘9˜Q“<ÐÜÐ9Ó:Ð:rf   c                 óœ  — t        |d«      r|j                  t        t        fv S t        |d«      r-|j                  \  }}|t        t        fv xs |t        t        fv S t        |t        «      st        |t        j                  «      ry| j                  |«      }t        |d«      st        |d«      r| j                  |«      S t        d«      ‚)a«  
        Return *True* if the absolute value of *x* is infinite;
        otherwise return *False*::

            >>> from mpmath import *
            >>> isinf(inf)
            True
            >>> isinf(-inf)
            True
            >>> isinf(3)
            False
            >>> isinf(3+4j)
            False
            >>> isinf(mpc(3,inf))
            True
            >>> isinf(mpc(inf,3))
            True

        ro   r5  Fzisinf() needs a number as input)rŽ   ro   r   r    r5  rŠ   r   r[   r™   r�   Úisinfr�   )ri  r’   ÚreÚims       rd   r�  zPythonMPContext.isinfÉ  s©   € ô( �1�gÔØ—7‘7œt¤U˜mÐ+Ð+Ü�1�gÔØ—W‘W‰FˆB�Øœ$¤˜Ð&Ò=¨"´´u°Ð*=Ð=Ü�aœÔ#¤z°!´X·\±\Ô'BØØ�K‰K˜‹NˆÜ�1�gÔ¤'¨!¨WÔ"5Ø—9‘9˜Q“<ÐÜÐ9Ó:Ð:rf   c                 óä  — t        |d«      rt        |j                  d   «      S t        |d«      rG|j                  \  }}t        |d   «      }t        |d   «      }|t        k(  r|S |t        k(  r|S |xr |S t        |t        «      st        |t        j                  «      rt        |«      S | j                  |«      }t        |d«      st        |d«      r| j                  |«      S t        d«      ‚)aº  
        Determine whether *x* is "normal" in the sense of floating-point
        representation; that is, return *False* if *x* is zero, an
        infinity or NaN; otherwise return *True*. By extension, a
        complex number *x* is considered "normal" if its magnitude is
        normal::

            >>> from mpmath import *
            >>> isnormal(3)
            True
            >>> isnormal(0)
            False
            >>> isnormal(inf); isnormal(-inf); isnormal(nan)
            False
            False
            False
            >>> isnormal(0+0j)
            False
            >>> isnormal(0+3j)
            True
            >>> isnormal(mpc(2,nan))
            False
        ro   r   r5  z"isnormal() needs a number as input)rŽ   Úboolro   r5  r   rŠ   r   r[   r™   r�   Úisnormalr�   )ri  r’   r‘  r’  Ú	re_normalÚ	im_normals         rd   r•  zPythonMPContext.isnormalé  sÏ   € ô0 �1�gÔÜ˜Ÿ™ ™
Ó#Ð#Ü�1�gÔØ—W‘W‰FˆB�Ü˜R ™U›ˆIÜ˜R ™U›ˆIØ”UŠ{ 9Ð,Ø”UŠ{ 9Ð,ØÒ* Ð*Ü�aœÔ#¤z°!´X·\±\Ô'BÜ˜“7ˆNØ�K‰K˜‹NˆÜ�1�gÔ¤'¨!¨WÔ"5Ø—<‘< “?Ð"ÜÐ<Ó=Ð=rf   c                 óV  — t        |t        «      ryt        |d«      r0|j                  x\  }}}}}t	        |xr |dk\  xs	 |t
        k(  «      S t        |d«      rZ|j                  \  }}	|\  }
}}}|	\  }}}}|xr |dk\  xs	 |t
        k(  }|r|xr |dk\  xs	 |	t
        k(  }|xr |S |xr	 |	t
        k(  S t        |t        j                  «      r|j                  \  }}||z  dk(  S | j                  |«      }t        |d«      st        |d«      r| j                  ||«      S t        d«      ‚)a
  
        Return *True* if *x* is integer-valued; otherwise return
        *False*::

            >>> from mpmath import *
            >>> isint(3)
            True
            >>> isint(mpf(3))
            True
            >>> isint(3.2)
            False
            >>> isint(inf)
            False

        Optionally, Gaussian integers can be checked for::

            >>> isint(3+0j)
            True
            >>> isint(3+2j)
            False
            >>> isint(3+2j, gaussian=True)
            True

        Tro   ru   r5  zisint() needs a number as input)rŠ   r   rŽ   ro   r”  r   r5  r[   r™   rš   r�   Úisintr�   )ri  r’   Úgaussianr�   r‚   rƒ   r„   Úxvalr‘  r’  ÚrsignÚrmanÚrexpÚrbcÚisignÚimanÚiexpÚibcÚre_isintÚim_isintrœ   r�   s                         rd   r™  zPythonMPContext.isint  s3  € ô2 �aœÔ#ØÜ�1�gÔØ()¯©Ð/ÑˆD�#�s˜B Ü˜Ò) ¨¡Ò;¨d´e©mÓ<Ð<Ü�1�gÔØ—W‘W‰FˆB�Ø%'Ñ"ˆE�4˜˜sØ%'Ñ"ˆE�4˜˜sØÒ* ¨¡Ò:¨r´U©{ˆHÙØ Ò. T¨Q¡YÒ>°2¼±;�ØÒ, HÐ,ØÒ+ ¤e¡Ð+Ü�aœŸ™Ô&Ø—7‘7‰DˆAˆqØ�q‘5˜A‘:ÐØ�K‰K˜‹NˆÜ�1�gÔ¤'¨!¨WÔ"5Ø—9‘9˜Q Ó)Ð)ÜÐ9Ó:Ð:rf   c                 ó˜  — | j                   \  }}g }g }|D �]o  }dx}	}
t        |d«      r|j                  }	nht        |d«      r|j                  \  }	}
nL| j	                  |«      }t        |d«      r|j                  }	n"t        |d«      r|j                  \  }	}
nt
        ‚|
r¸|rq|r7|j                  t        |	|	«      «       |j                  t        |
|
«      «       ŒÆt        |	|
fd|dz   «      \  }	}
|j                  |	«       |j                  |
«       Œþ|r|j                  t        |	|
f|«      «       �Œ|j                  |	«       |j                  |
«       �ŒC|rt        |	|	«      }	n|rt        |	«      }	|j                  |	«       �Œr t        ||||«      }|r | j                  |t        |||«      f«      }|S | j                  |«      }|S )aX  
        Calculates a sum containing a finite number of terms (for infinite
        series, see :func:`~mpmath.nsum`). The terms will be converted to
        mpmath numbers. For len(terms) > 2, this function is generally
        faster and produces more accurate results than the builtin
        Python function :func:`sum`.

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fsum([1, 2, 0.5, 7])
            mpf('10.5')

        With squared=True each term is squared, and with absolute=True
        the absolute value of each term is used.
        ru   ro   r5  rt   é
   )rx   rŽ   ro   r5  r�   ra   Úappendr'   rK   r?   r"   r5   ro  r    )ri  ÚtermsÚabsoluteÚsquaredrq   rÊ   r  r  ÚtermÚrevalÚimvalr»   s               rd   ÚfsumzPythonMPContext.fsum@  s¦  € ð  ×&Ñ&‰	ˆˆcØˆØˆØó !	#ˆDØÐˆE�EÜ�t˜WÔ%ØŸ
™
‘Ü˜˜wÔ'Ø#Ÿz™z‘�‘uà—{‘{ 4Ó(�Ü˜4 Ô)Ø ŸJ™J‘EÜ˜T 7Ô+Ø#'§:¡:‘L�E™5ä-Ð-ÙÙÙØŸ™¤G¨E°%Ó$8Ô9ØŸ™¤G¨E°%Ó$8Õ9ä'2°E¸%°=ÀÀ4ÈÁ7Ó'K™˜˜uØŸ™ EÔ*ØŸ™ EÕ*ÙØ—K‘K¤¨¨u¨°tÓ <Ö=à—K‘K Ô&Ø—K‘K Ö&áÜ# E¨5Ó1‘EÙÜ# E›N�EØ—‘˜EÖ"ðC!	#ôD �D˜$  XÓ.ˆÙØ—‘˜a¤¨¨t°SÓ!9Ð:Ó;ˆAð ˆð —‘˜Q“ˆAØˆrf   Nc           	      ó  — |�t        ||«      }| j                  \  }}g }g }t        }| j                  | j                  f}	|D �]þ  \  }
}t        |
«      |	vr| j                  |
«      }
t        |«      |	vr| j                  |«      } ||
d«      } ||d«      }|r2|r0|j                  t        |
j                  |j                  «      «       Œ‰ ||
d«      } ||d«      }|ra|r_|
j                  }|j                  \  }}|rt        |«      }|j                  t        ||«      «       |j                  t        ||«      «       Œþ|rU|rS|
j                  \  }}|j                  }|j                  t        ||«      «       |j                  t        ||«      «       �ŒU|r¤|r¢|
j                  \  }}|j                  \  }}|rt        |«      }|j                  t        ||«      «       |j                  t        t        ||«      «      «       |j                  t        ||«      «       |j                  t        ||«      «       �Œût        ‚ t        |||«      }|r | j                  |t        |||«      f«      }|S | j                  |«      }|S )a.  
        Computes the dot product of the iterables `A` and `B`,

        .. math ::

            \sum_{k=0} A_k B_k.

        Alternatively, :func:`~mpmath.fdot` accepts a single iterable of pairs.
        In other words, ``fdot(A,B)`` and ``fdot(zip(A,B))`` are equivalent.
        The elements are automatically converted to mpmath numbers.

        With ``conjugate=True``, the elements in the second vector
        will be conjugated:

        .. math ::

            \sum_{k=0} A_k \overline{B_k}

        **Examples**

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> A = [2, 1.5, 3]
            >>> B = [1, -1, 2]
            >>> fdot(A, B)
            mpf('6.5')
            >>> list(zip(A, B))
            [(2, 1), (1.5, -1), (3, 2)]
            >>> fdot(_)
            mpf('6.5')
            >>> A = [2, 1.5, 3j]
            >>> B = [1+j, 3, -1-j]
            >>> fdot(A, B)
            mpc(real='9.5', imag='-1.0')
            >>> fdot(A, B, conjugate=True)
            mpc(real='3.5', imag='-5.0')

        ro   r5  )Úziprx   rŽ   r7  r˜   rz   r�   r¨  r'   ro   r5  r$   ra   r5   ro  r    )ri  ÚAÚBr  rq   rÊ   r  r  Úhasattr_r�  r”   r•   Úa_realÚb_realÚ	a_complexÚ	b_complexÚavalÚbreÚbimÚareÚaimÚbvalr»   s                          rd   ÚfdotzPythonMPContext.fdot|  s7  € ðN ˆ=Ü�A�q“	ˆAØ×&Ñ&‰	ˆˆcØˆØˆÜˆØ—‘˜#Ÿ'™'Ð"ˆØó !	*‰DˆAˆqÜ�A‹w˜eÑ#¨¯©°Q« QÜ�A‹w˜eÑ#¨¯©°Q« QÙ˜a Ó)ˆFÙ˜a Ó)ˆFÙ™&Ø—‘œG A§G¡G¨Q¯W©WÓ5Ô6ØÙ   GÓ,ˆIÙ   GÓ,ˆIÙ™)Ø—w‘w�ØŸ7™7‘��SÙÜ! #›,�CØ—‘œG D¨#Ó.Ô/Ø—‘œG D¨#Ó.Õ/Ù™IØŸ7™7‘��SØ—w‘w�Ø—‘œG C¨Ó.Ô/Ø—‘œG C¨Ó.Ö/Ù™yàŸ7™7‘��SØŸ7™7‘��SÙÜ! #›,�CØ—‘œG C¨Ó-Ô.Ø—‘œG¤G¨C°Ó$5Ó6Ô7Ø—‘œG C¨Ó-Ô.Ø—‘œG C¨Ó-Ö.ä)Ð)ðC!	*ôD �D˜$ Ó$ˆÙØ—‘˜a¤¨¨t°SÓ!9Ð:Ó;ˆAð ˆð —‘˜Q“ˆAØˆrf   c                 óŒ   ‡ ‡‡‡— ˆ ˆˆˆfd„}‰j                   dd Št        j                  j                  ‰d|z  «      |_        |S )aO  
        Given a low-level mpf_ function, and optionally similar functions
        for mpc_ and mpi_, defines the function as a context method.

        It is assumed that the return type is the same as that of
        the input; the exception is that propagation from mpf to mpc is possible
        by raising ComplexResult.

        c                 ó\  •— t        | «      ‰j                  vr‰j                  | «      } ‰j                  \  }}|r6|j	                  d|«      }d|v rt        |d   «      }|j	                  d|«      }t        | d«      r$	 ‰j                   ‰| j                  ||«      «      S t        | d«      r#‰j                   ‰| j                  ||«      «      S t        ‰›dt        | «      ›�«      ‚# t        $ r9 ‰j                  r‚ ‰j                   ‰| j                  t        f||«      «      cY S w xY w)Nrq   rr   rs   ro   r5  z of a )rz   r�  r�   rx   ry   r   rŽ   r    ro   r   rs  ro  r   r5  ra   )r’   r€   rq   rs   ri  Úmpc_fÚmpf_fr  s       €€€€rd   Úfz/PythonMPContext._wrap_libmp_function.<locals>.fÝ  s  ø€ Ü�A‹w˜cŸi™iÑ'Ø—K‘K “N�Ø ×/Ñ/‰NˆD�(ÙØ—z‘z &¨$Ó/�Ø˜F‘?Ü& v¨e¡}Ó5�DØ!Ÿ:™: j°(Ó;�Ü�q˜'Ô"ðQØŸ<™<©¨a¯g©g°t¸XÓ(FÓGÐGô ˜˜GÔ$Ø—|‘|¡E¨!¯'©'°4¸Ó$BÓCÐCÜ%²d¼DÀ¼GÐ&DÓEÐEøô %ò Qà×'Ò'ØØŸ<™<©¨q¯w©w¼Ð.>ÀÀhÓ(OÓPÒPð	Qús   Á>"C) Ã)?D+Ä*D+rv   NzComputes the %s of x)rg   r\   Ú__dict__ry   rj   )ri  rÃ  rÂ  Úmpi_fÚdocrÄ  r  s   ```   @rd   Ú_wrap_libmp_functionz$PythonMPContext._wrap_libmp_functionÓ  s@   û€ ÷	Fð( �~‰~˜a˜bÐ!ˆÜ!×*Ñ*×.Ñ.¨tÐ5KÈcÑ5QÓRˆŒ	Øˆrf   c                 ó’   ‡— |rˆfd„}n‰}t         j                  j                  |‰j                  «      |_        t	        | ||«       y )Nc                 óØ   •— | j                   }|D �cg c]
  } ||«      ‘Œ }}| j                  }	 | xj                  dz  c_         ‰| g|¢­i |¤Ž}|| _        |­S c c}w # || _        w xY w)Nr§  )r�   rq   )ri  r  r€   r�   r”   rq   ÚretvalrÄ  s          €rd   Ú	f_wrappedz0PythonMPContext._wrap_specfun.<locals>.f_wrappedù  sp   ø€ ØŸ+™+�Ø,0Ö1 q™ �
Ð1�Ð1Ø—x‘x�ð$Ø—H’H ‘N•HÙ˜sÐ4 TÒ4¨VÑ4�Fà#�C”HØ�w�ùò 2øð  $�C•Hús   ’A°!A  Á 	A))r\   rÅ  ry   rj   Úsetattr)rb   r  rÄ  ÚwraprÌ  s     `  rd   Ú_wrap_specfunzPythonMPContext._wrap_specfunö  s=   ø€ áõ	ð ˆIÜ)×2Ñ2×6Ñ6°t¸Q¿Y¹YÓGˆ	ÔÜ��T˜9Õ%rf   c                 ót  — t        |d«      r|j                  \  }}|t        k7  �r&|dfS t        |d«      r|j                  }�nt	        |«      t
        v rt        |«      dfS d }t        |t        «      r|\  }}nZt        |d«      r|j                  \  }}n>t        |t        «      r.d|v r*|j                  d«      \  }}t        |«      }t        |«      }|� |z  s||z  dfS | j                  ||«      dfS | j                  |«      }t        |d«      r|j                  \  }}|t        k7  r!|dfS t        |d«      r|j                  }n|dfS |\  }}}}	|r^|d	k\  rD|r| }|d
k\  rt        |«      |z  dfS |d	k\  r%t        |«      d| z  }}| j                  ||«      dfS | j                  |«      }|dfS |sy|dfS )Nr5  ÚCro   ÚZrš   ú/ÚQÚUéüÿÿÿru   r   ÚR)ru   rÒ  )rŽ   r5  r   ro   rz   r   rÃ   rŠ   r|   rš   r   Úsplitr™   r�   r    )
ri  r’   r…   r’  rœ   r�   r�   r‚   rƒ   r„   s
             rd   Ú_convert_paramzPythonMPContext._convert_param  sÇ  € Ü�1�gÔØ—G‘G‰EˆAˆrØ”U‹{Ø˜#�v�Ü�Q˜Ô Ø—‘ŠAä�A‹wœ)Ñ#Ü˜1“v˜s�{Ð"ØˆAÜ˜!œUÔ#Ø‘�‘1Ü˜˜GÔ$Ø—w‘w‘�‘1Ü˜AœzÔ*¨s°a©xØ—w‘w˜s“|‘��1Ü˜“F�Ü˜“F�Øˆ}Ø˜1’uØ ™6 3˜;Ð&Ø—w‘w˜q “| SÐ(Ð(Ø—‘˜A“ˆAÜ�q˜'Ô"ØŸ™‘��2Øœ’;Ø˜c˜6�MÜ˜˜GÔ$Ø—G‘G‘à˜#�v�ØÑˆˆc�3˜ÙØ�bŠyÙØ˜$�CØ˜!’8Ü˜s›8 s™?¨CÐ/Ð/Ø˜"’9Ü˜s›8 a¨3¨$¡i�q�AØŸ7™7 1 Q›<¨Ð,Ð,Ø—‘˜Q“ˆAØ�c�6ˆMÙØà�c�6ˆMrf   c                 óœ   — |\  }}}}|r||z   S |t         k(  r| j                  S |t        k(  s	|t        k(  r| j                  S | j
                  S r`   )r   Úninfr   r    ÚinfÚnan)ri  r’   r�   r‚   rƒ   r„   s         rd   Ú_mpf_magzPythonMPContext._mpf_mag9  sK   € ØÑˆˆc�3˜ÙØ�r‘6ˆMØ”Š:Ø—8‘8ˆOØ”Š9˜œUš
Ø—7‘7ˆNØ�w‰wˆrf   c                 óê  — t        |d«      r| j                  |j                  «      S t        |d«      rp|j                  \  }}|t        k(  r| j                  |«      S |t        k(  r| j                  |«      S dt        | j                  |«      | j                  |«      «      z   S t        |t        «      r"|rt        t        |«      «      S | j                  S t        |t        j                  «      r@|j                  \  }}|r#dt        t        |«      «      z   t        |«      z
  S | j                  S | j                  |«      }t        |d«      st        |d«      r| j                  |«      S t!        d«      ‚)a¯  
        Quick logarithmic magnitude estimate of a number. Returns an
        integer or infinity `m` such that `|x| <= 2^m`. It is not
        guaranteed that `m` is an optimal bound, but it will never
        be too large by more than 2 (and probably not more than 1).

        **Examples**

            >>> from mpmath import *
            >>> mp.pretty = True
            >>> mag(10), mag(10.0), mag(mpf(10)), int(ceil(log(10,2)))
            (4, 4, 4, 4)
            >>> mag(10j), mag(10+10j)
            (4, 5)
            >>> mag(0.01), int(ceil(log(0.01,2)))
            (-6, -6)
            >>> mag(0), mag(inf), mag(-inf), mag(nan)
            (-inf, +inf, +inf, nan)

        ro   r5  r   zrequires an mpf/mpc)rŽ   rÞ  ro   r5  r   rv  rŠ   r   r6   ÚabsrÛ  r[   r™   rš   r�   Úmagr�   )ri  r’   rB  rC  rœ   r�   s         rd   rá  zPythonMPContext.magC  s'  € ô* �1�gÔØ—<‘< §¡Ó(Ð(Ü�Q˜Ô Ø—7‘7‰DˆAˆqØ”EŠzØ—|‘| A“Ð&Ø”EŠzØ—|‘| A“Ð&Ø”S˜Ÿ™ a›¨#¯,©,°q«/Ó:Ñ:Ð:Ü˜œ9Ô%ÙÜ¤ A£Ó'Ð'Ø—8‘8ˆOÜ˜œ8Ÿ<™<Ô(Ø—7‘7‰DˆAˆqÙØœ8¤C¨£FÓ+Ñ+¬h°q«kÑ9Ð9Ø—8‘8ˆOà—‘˜A“ˆAÜ�q˜'Ô"¤g¨a°Ô&9Ø—w‘w˜q“zÐ!äÐ 5Ó6Ð6rf   )T)F)FF)NF)NNz<no doc>)rg   rh   ri   rj  r    ro  rt  ry  r{  r  rq   rr   r�   r‚  rŽ  r�  r•  r™  r¯  r¿  rÈ  r
  rÏ  rÙ  rÞ  rá  rl   rf   rd   re  re  G  s•   „ ò
#òò
ò
!ò
"ò"ñ Ñ)¨9Ó5€DÙ
Ñ'¨Ó
2€Có01òd
=ò;ò8;ò@&>óP-;ó^:óxUón ðF ñ&ó ð&ò"/òbó,7rf   re  ru   N)r&  r&  r&  )}Úlibmp.backendr   r   Úlibmpr   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   rV   rW   rX   rY   rZ   r&  r[   r\   r'  re   r{   r^   rn   r  Ú
return_mpfÚ
return_mpcÚmpf_pow_samer  rë   r  r  r  r   r!  r"  ra  r]  rb  rò   rc  r$  r4  rÍ   r—   re  rƒ  ÚComplexÚregisterÚRealÚImportErrorrl   rf   rd   ú<module>rë     sx  ð÷ -÷÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ÷ ñ õ. Ý à‡n�n€ô"�ô "ôC)ˆ9ô C)ðJ€ð< =€
Ø<�
ò ’:ð€óñ ˜ØØ*Ø9ó;€„ñ
 ˜Ø/°*Ñ<Ø:¸ZÑGØ3°jÑ@óB€„ñ
 ˜Ø/°*Ñ<Ø:¸ZÑGØ8¸:ÑEóG€„ñ
 ˜Ø/°*Ñ<Ø4°zÑAØ3°jÑ@óB€„ñ
 ˜Ø/°*Ñ<Ø:¸ZÑGØ3°jÑ@óB€„ñ
 ˜Ø/°*Ñ<Ø:¸ZÑGØ1ó3€„ñ
 ˜ØØ4°zÑAØ8¸:ÑEóG€„ð
 —‘€„Ø—‘€„Ø—<‘<€Ô Ø—M‘M€Ô ôJ�ô Jô:Z:ˆ9ô Z:ðz ˜$�€ôh7�fô h7ðb	ÛØ‡O�O×Ñ˜TÔ"Ø‡L�L×Ñ˜$ÕøØò 	Ùð	ús   È:I ÉI	ÉI	