§
    JŠtj,Á  ã                   ó´  — d Z dZddlZddlZddlmZ ddlmZ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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@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^mZ dd	l	m_Z_ dd
l	m`Z` eajb        Zc ejd        d¦  «        Zeedk    rddlfmgZh ddlfmic mjc mkZl nddlmmnZh ddl	mmZl ddlmmoZompZpmqZq  G d„ dehe¦  «        Zr G d„ d¦  «        Zsetdk    rddluZu eujv        ¦   «          dS dS )z[
This module defines the mpf, mpc classes, and standard functions for
operating with them.
Ú	plaintexté    Né   )ÚStandardBaseContext)Ú
basestringÚBACKEND)Úlibmp)UÚ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_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   )Úfunction_docs)Úrationalz\^\(?(?P<re>[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?)??(?P<im>[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?j)?\)?$Úsage)ÚContext)ÚPythonMPContext)Úctx_mp_python)Ú_mpfÚ_mpcÚ	mpnumericc                   óz  — e 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d„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zed„ ¦   «         Zed„ ¦   «         Zd=d„Zd=d„Zd=d„Zd=d„Z d>d"„Z!d?d$„Z"d%„ Z#d&„ Z$d'„ Z%d(Z&d)Z'd@d+„Z(d,„ Z)d-„ Z*d.„ Z+d/„ Z,d0„ Z-d1„ Z.d2„ Z/d3„ Z0d4„ Z1d5„ Z2d6„ Z3d7„ Z4d8„ Z5d9„ Z6	 d:gdfd;„Z7d S )AÚ	MPContextzH
    Context for multiprecision arithmetic with a global precision.
    c                 óÆ  — t          j        | ¦  «         d| _        d| _        | j        | j        | j        g| _        t          j	        | _
        |                      ¦   «          t          j        | ¦  «         t          j	        | _	        |                      ¦   «          i | _        |                      ¦   «          	 t           j        | j        j        _        t           j        | j        j        _        t           j        | j        j        _        t           j        | j        j        _        n|# t.          $ ro t           j        | j        j        _        t           j        | j        j        _        t           j        | j        j        _        t           j        | j        j        _        Y nw xY wt           j        | j        _        t           j        | j        _        t           j        | j        _        d S ©NF)ÚBaseMPContextÚ__init__Útrap_complexÚprettyÚmpfÚmpcÚconstantÚtypesr^   ÚmpqÚ_mpqÚdefaultr   Úinit_builtinsÚhyp_summatorsÚ_init_aliasesr]   Ú	bernoulliÚim_funcÚfunc_docÚprimepiÚpsiÚatan2ÚAttributeErrorÚ__func__ÚdigammaÚcospiÚsinpi©Úctxs    úK/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/mpmath/ctx_mp.pyrk   zMPContext.__init__?   si  € ÝÔ˜sÑ#Ô#Ð#Ø ˆÔØˆŒ
Ø”W˜cœg s¤|Ð4ˆŒ	Ý”<ˆŒØ�Š‰ŒˆÝÔ$ SÑ)Ô)Ð)å”,ˆŒØ×ÒÑÔÐàˆÔà×ÒÑÔÐð
	>Ý-:Ô-DˆCŒMÔ!Ô*Ý+8Ô+@ˆCŒKÔÔ(Ý'4Ô'8ˆCŒGŒOÔ$Ý)6Ô)<ˆCŒIÔÔ&Ð&øÝð 	>ð 	>ð 	>å.;Ô.EˆCŒMÔ"Ô+Ý,9Ô,AˆCŒKÔ Ô)Ý(5Ô(9ˆCŒGÔÔ%Ý*7Ô*=ˆCŒIÔÔ'Ð'Ð'ð	>øøøõ  -Ô4ˆŒÔÝ*Ô0ˆŒ	ÔÝ*Ô0ˆŒ	ÔÐÐs   Â6A,D# Ä#A6FÆFc                 ó  — | j         }| j        }|                      t          ¦  «        | _        |                      t
          ¦  «        | _        |                      t
          t          f¦  «        | _        |                      t          ¦  «        | _
        |                      t          ¦  «        | _        |                      t          ¦  «        | _        |                      d„ dd¦  «        }|| _        |                      t"          dd¦  «        | _        |                      t&          dd¦  «        | _        |                      t*          dd¦  «        | _        |                      t.          d	d
¦  «        | _        |                      t2          dd¦  «        | _        |                      t6          dd¦  «        | _        |                      t:          dd¦  «        | _        |                      t>          dd¦  «        | _         |                      tB          dd¦  «        | _"        |                      tF          dd¦  «        | _$        |                      tJ          dd¦  «        | _&        |                      tN          dd¦  «        | _(        |                      tR          dd¦  «        | _*        |  +                    tX          j-        tX          j.        ¦  «        | _/        |  +                    tX          j0        tX          j1        ¦  «        | _2        |  +                    tX          j3        tX          j4        ¦  «        | _5        |  +                    tX          j6        tX          j7        ¦  «        | _8        |  +                    tX          j9        tX          j:        ¦  «        | _;        |  +                    tX          j<        tX          j=        ¦  «        | _>        |  +                    tX          j?        tX          j@        ¦  «        | _A        |  +                    tX          jB        tX          jC        ¦  «        | _D        |  +                    tX          jE        tX          jF        ¦  «        | _G        |  +                    tX          jH        tX          jI        ¦  «        | _J        |  +                    tX          jK        tX          jL        ¦  «        | _M        |  +                    tX          jN        tX          jO        ¦  «        | _P        |  +                    tX          jQ        tX          jR        ¦  «        | _S        |  +                    tX          jT        tX          jU        ¦  «        | _V        |  +                    tX          jW        tX          jX        ¦  «        | _Y        |  +                    tX          j6        tX          j7        ¦  «        | _8        |  +                    tX          jZ        tX          j[        ¦  «        | _\        |  +                    tX          j]        tX          j^        ¦  «        | __        |  +                    tX          j`        tX          ja        ¦  «        | _b        |  +                    tX          jc        tX          jd        ¦  «        | _e        |  +                    tX          jf        tX          jg        ¦  «        | _h        |  +                    tX          ji        tX          jj        ¦  «        | _k        |  +                    tX          jl        tX          jm        ¦  «        | _n        |  +                    tX          jo        tX          jp        ¦  «        | _q        |  +                    tX          jr        tX          js        ¦  «        | _t        |  +                    tX          ju        tX          jv        ¦  «        x| _w        | _x        |  +                    tX          jy        tX          jz        ¦  «        | _{        |  +                    tX          j|        tX          j}        ¦  «        | _~        |  +                    tX          j        tX          j€        ¦  «        | _�        |  +                    tX          j‚        tX          jƒ        ¦  «        x| _„        | _…        |  +                    tX          j†        tX          j‡        ¦  «        | _ˆ        |  +                    tX          j‰        tX          jŠ        ¦  «        | _‹        |  +                    tX          jŒ        tX          j�        ¦  «        | _Ž        |  +                    tX          j�        tX          j�        ¦  «        | _‘        |  +                    tX          j’        tX          j“        ¦  «        | _”        |  +                    tX          j•        tX          j–        ¦  «        | _—        |  +                    tX          j˜        tX          j™        ¦  «        | _š        |  +                    tX          j›        tX          jœ        ¦  «        | _�        |  +                    tX          jž        tX          jŸ        ¦  «        | _         |  +                    tX          j¡        d ¦  «        | _¢        |  +                    tX          j£        d ¦  «        | _¤        |  +                    tX          j¥        tX          j¦        ¦  «        | _§        |  +                    tX          j¨        tX          j©        ¦  «        | _ª        �tW          | d| j/        ¦  «        | _/        �tW          | d| j;        ¦  «        | _;        �tW          | d| j5        ¦  «        | _5        �tW          | d | jG        ¦  «        | _G        �tW          | d!| jD        ¦  «        | _D        d S )"Nc                 ó   — dt           d| z
  dfS )Nr   r   )r   )ÚprecÚrnds     r…   ú<lambda>z)MPContext.init_builtins.<locals>.<lambda>m   s   € ¨aµ¸!¸D¹&À!Ð-D€ ó    zepsilon of working precisionÚepsÚpizln(2)Úln2zln(10)Úln10zGolden ratio phiÚphiz
e = exp(1)ÚezEuler's constantÚeulerzCatalan's constantÚcatalanzKhinchin's constantÚkhinchinzGlaisher's constantÚglaisherzApery's constantÚaperyz1 deg = pi / 180ÚdegreezTwin prime constantÚ	twinprimezMertens' constantÚmertensÚ
_sage_sqrtÚ	_sage_expÚ_sage_lnÚ	_sage_cosÚ	_sage_sin)¬rn   ro   Úmake_mpfr   Úoner    ÚzeroÚmake_mpcÚjr!   Úinfr"   Úninfr#   Únanrp   rŒ   rP   r�   rT   rŽ   rU   r�   rS   r�   rR   r‘   rV   r’   rW   r“   rY   r”   rZ   r•   rX   r–   rQ   r—   r[   r˜   r\   r™   Ú_wrap_libmp_functionr   Úmpf_sqrtÚmpc_sqrtÚsqrtÚmpf_cbrtÚmpc_cbrtÚcbrtÚmpf_logÚmpc_logÚlnÚmpf_atanÚmpc_atanÚatanÚmpf_expÚmpc_expÚexpÚmpf_expjÚmpc_expjÚexpjÚ
mpf_expjpiÚ
mpc_expjpiÚexpjpiÚmpf_sinÚmpc_sinÚsinÚmpf_cosÚmpc_cosÚcosÚmpf_tanÚmpc_tanÚtanÚmpf_sinhÚmpc_sinhÚsinhÚmpf_coshÚmpc_coshÚcoshÚmpf_tanhÚmpc_tanhÚtanhÚmpf_asinÚmpc_asinÚasinÚmpf_acosÚmpc_acosÚacosÚ	mpf_asinhÚ	mpc_asinhÚasinhÚ	mpf_acoshÚ	mpc_acoshÚacoshÚ	mpf_atanhÚ	mpc_atanhÚatanhÚ
mpf_sin_piÚ
mpc_sin_pir‚   Ú
mpf_cos_piÚ
mpc_cos_pir�   Ú	mpf_floorÚ	mpc_floorÚfloorÚmpf_ceilÚmpc_ceilÚceilÚmpf_nintÚmpc_nintÚnintÚmpf_fracÚmpc_fracÚfracÚmpf_fibonacciÚmpc_fibonacciÚfibÚ	fibonacciÚ	mpf_gammaÚ	mpc_gammaÚgammaÚ
mpf_rgammaÚ
mpc_rgammaÚrgammaÚmpf_loggammaÚmpc_loggammaÚloggammaÚmpf_factorialÚmpc_factorialÚfacÚ	factorialÚmpf_psi0Úmpc_psi0r€   Úmpf_harmonicÚmpc_harmonicÚharmonicÚmpf_eiÚmpc_eiÚeiÚmpf_e1Úmpc_e1Úe1Úmpf_ciÚmpc_ciÚ_ciÚmpf_siÚmpc_siÚ_siÚ
mpf_ellipkÚ
mpc_ellipkÚellipkÚ
mpf_ellipeÚ
mpc_ellipeÚ_ellipeÚmpf_agm1Úmpc_agm1Úagm1Úmpf_erfÚ_erfÚmpf_erfcÚ_erfcÚmpf_zetaÚmpc_zetaÚ_zetaÚmpf_altzetaÚmpc_altzetaÚ_altzetaÚgetattr)r„   rn   ro   rŒ   s       r…   ru   zMPContext.init_builtins`   sÿ  € àŒgˆØŒgˆð —,’,�tÑ$Ô$ˆŒØ—<’<¥Ñ&Ô&ˆŒØ—’�e¥D˜\Ñ*Ô*ˆŒØ—,’,�tÑ$Ô$ˆŒØ—<’<¥Ñ&Ô&ˆŒØ—,’,�tÑ$Ô$ˆŒà�lŠlÐDÐDØ*¨Eñ3ô 3ˆàˆŒð —’�f d¨DÑ1Ô1ˆŒØ—,’,�w¨°Ñ7Ô7ˆŒØ—<’<¥¨(°FÑ;Ô;ˆŒØ—,’,�wÐ(:¸EÑBÔBˆŒØ—’�U L°#Ñ6Ô6ˆŒØ—L’L¥Ð,>ÀÑHÔHˆŒ	Ø—l’l¥;Ð0DÀiÑPÔPˆŒØ—|’|¥LÐ2GÈÑTÔTˆŒØ—|’|¥LÐ2GÈÑTÔTˆŒØ—L’L¥Ð,>ÀÑHÔHˆŒ	Ø—\’\¥*Ð.@À(ÑKÔKˆŒ
ØŸš¥]Ð4IÈ;ÑWÔWˆŒØ—l’l¥;Ð0CÀYÑOÔOˆŒð ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×)Ò)­%¬-½¼ÑGÔGˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×*Ò*­5¬=½%¼-ÑHÔHˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×-Ò-­eÔ.>ÅÔ@PÑQÔQˆŒ
Ø×*Ò*­5¬=½%¼-ÑHÔHˆŒØ×*Ò*­5¬=½%¼-ÑHÔHˆŒØ×*Ò*­5¬=½%¼-ÑHÔHˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×,Ò,­U¬_½e¼oÑNÔNˆŒ	Ø×,Ò,­U¬_½e¼oÑNÔNˆŒ	Ø×,Ò,­U¬_½e¼oÑNÔNˆŒ	Ø×,Ò,­UÔ-=½uÔ?OÑPÔPˆŒ	Ø×,Ò,­UÔ-=½uÔ?OÑPÔPˆŒ	Ø×,Ò,­U¬_½e¼oÑNÔNˆŒ	Ø×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ"%×":Ò":½5Ô;NÕPUÔPcÑ"dÔ"dÐdˆŒ�#”-à×,Ò,­U¬_½e¼oÑNÔNˆŒ	Ø×-Ò-­eÔ.>ÅÔ@PÑQÔQˆŒ
Ø×/Ò/µÔ0BÅEÔDVÑWÔWˆŒØ"%×":Ò":½5Ô;NÕPUÔPcÑ"dÔ"dÐdˆŒ�#”-à×.Ò.­u¬~½u¼~ÑNÔNˆŒØ×/Ò/µÔ0BÅEÔDVÑWÔWˆŒØ×)Ò)­%¬,½¼ÑEÔEˆŒØ×)Ò)­%¬,½¼ÑEÔEˆŒØ×*Ò*­5¬<½¼ÑFÔFˆŒØ×*Ò*­5¬<½¼ÑFÔFˆŒØ×-Ò-­eÔ.>ÅÔ@PÑQÔQˆŒ
Ø×.Ò.­uÔ/?ÅÔAQÑRÔRˆŒØ×+Ò+­E¬N½E¼NÑKÔKˆŒØ×+Ò+­E¬M¸4Ñ@Ô@ˆŒØ×,Ò,­U¬^¸TÑBÔBˆŒ	Ø×,Ò,­U¬^½U¼^ÑLÔLˆŒ	Ø×/Ò/µÔ0AÅ5ÔCTÑUÔUˆŒö ˜3 ¨c¬hÑ7Ô7ˆŒÞ˜#˜{¨C¬GÑ4Ô4ˆŒÞ˜˜j¨#¬&Ñ1Ô1ˆŒÞ˜#˜{¨C¬GÑ4Ô4ˆŒÞ˜#˜{¨C¬GÑ4Ô4ˆŒˆˆr‹   c                 ó,   — |                      |¦  «        S ©N)r9   )r„   Úxrˆ   s      r…   r9   zMPContext.to_fixed¶   s   € Ø�zŠz˜$ÑÔÐr‹   c                 óÀ   — |                       |¦  «        }|                       |¦  «        }|                      t          j        |j        |j        g| j        ¢R Ž ¦  «        S )z€
        Computes the Euclidean norm of the vector `(x, y)`, equal
        to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real.)ÚconvertrŸ   r   Ú	mpf_hypotÚ_mpf_Ú_prec_rounding)r„   r&  Úys      r…   ÚhypotzMPContext.hypot¹   sO   € ð �KŠK˜‰NŒNˆØ�KŠK˜‰NŒNˆØ�|Š|�EœO¨A¬G°Q´WÐR¸sÔ?QÐRÐRÐRÑSÔSÐSr‹   c                 ó\  — t          |                      |¦  «        ¦  «        }|dk    r|                      |¦  «        S t          |d¦  «        st          ‚| j        \  }}t          j        ||j        ||d¬¦  «        \  }}|€|  	                    |¦  «        S |  
                    ||f¦  «        S )Nr   r*  T)rô   )ÚintÚ_rer	  ÚhasattrÚNotImplementedErrorr+  r   Ú
mpf_expintr*  rŸ   r¢   ©r„   ÚnÚzrˆ   ÚroundingÚrealÚimags          r…   Ú_gamma_upper_intzMPContext._gamma_upper_intÁ   s¢   € Ý�—’˜‘
”
‰OŒOˆØ�Š6ˆ6Ø—6’6˜!‘9”9ÐÝ�q˜'Ñ"Ô"ð 	&Ý%Ð%ØÔ+‰ˆˆhÝÔ% a¨¬°$¸ÈÐMÑMÔM‰
ˆˆdØˆ<Ø—<’< Ñ%Ô%Ð%à—<’<  t Ñ-Ô-Ð-r‹   c                 ó2  — t          |¦  «        }|dk    r|                      |¦  «        S t          |d¦  «        st          ‚| j        \  }}t          j        ||j        ||¦  «        \  }}|€|                      |¦  «        S |  	                    ||f¦  «        S )Nr   r*  )
r/  r	  r1  r2  r+  r   r3  r*  rŸ   r¢   r4  s          r…   Ú_expint_intzMPContext._expint_intÎ   s“   € Ý�‰FŒFˆØ�Š6ˆ6Ø—6’6˜!‘9”9ÐÝ�q˜'Ñ"Ô"ð 	&Ý%Ð%ØÔ+‰ˆˆhÝÔ% a¨¬°$¸ÑAÔA‰
ˆˆdØˆ<Ø—<’< Ñ%Ô%Ð%à—<’<  t Ñ-Ô-Ð-r‹   c                 ó>  — t          |d¦  «        r\	 |                      t          j        |j        |g| j        ¢R Ž ¦  «        S # t          $ r | j        r‚ |j        t          j        f}Y nw xY w|j	        }|  
                    t          j        ||g| j        ¢R Ž ¦  «        S ©Nr*  )r1  rŸ   r   Úmpf_nthrootr*  r+  r   rl   r    Ú_mpc_r¢   Úmpc_nthroot©r„   r&  r5  s      r…   Ú_nthrootzMPContext._nthrootÛ   s³   € Ý�1�gÑÔð 	ð+Ø—|’|¥EÔ$5°a´g¸qÐ$VÀ3ÔCUÐ$VÐ$VÐ$VÑWÔWÐWøÝ ð +ð +ð +ØÔ#ð ØØ”W�eœkÐ*���ð+øøøð
 ”ˆAØ�|Š|�EÔ-¨a°ÐH°SÔ5GÐHÐHÐHÑIÔIÐIs   ’/A Á%A*Á)A*c                 ó  — | j         \  }}t          |d¦  «        r/|                      t          j        ||j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          j        ||j        ||¦  «        ¦  «        S d S ©Nr*  r@  )	r+  r1  rŸ   r   Úmpf_besseljnr*  r¢   Úmpc_besseljnr@  )r„   r5  r6  rˆ   r7  s        r…   Ú_besseljzMPContext._besseljç   sŠ   € ØÔ+‰ˆˆhÝ�1�gÑÔð 	PØ—<’<¥Ô 2°1°a´g¸tÀXÑ NÔ NÑOÔOÐOÝ�Q˜Ñ Ô ð 	PØ—<’<¥Ô 2°1°a´g¸tÀXÑ NÔ NÑOÔOÐOð	Pð 	Pr‹   r   c                 óä  — | j         \  }}t          |d¦  «        rWt          |d¦  «        rG	 t          j        |j        |j        ||¦  «        }|                      |¦  «        S # t          $ r Y nw xY wt          |d¦  «        r|j        t          j        f}n|j        }t          |d¦  «        r|j        t          j        f}n|j        }|  	                    t          j
        ||||¦  «        ¦  «        S r>  )r+  r1  r   Úmpf_agmr*  rŸ   r   r    r@  r¢   Úmpc_agm)r„   ÚaÚbrˆ   r7  Úvs         r…   Ú_agmzMPContext._agmî   sñ   € ØÔ+‰ˆˆhÝ�1�gÑÔð 	¥7¨1¨gÑ#6Ô#6ð 	ðÝ”M !¤'¨1¬7°D¸(ÑCÔC�Ø—|’| A‘”Ð&øÝ ð ð ð Ø�ðøøøå�1�gÑÔð 	 Q¤W­e¬kÐ$:  Ø”'ˆaÝ�1�gÑÔð 	 Q¤W­e¬kÐ$:  Ø”'ˆaØ�|Š|�EœM¨!¨Q°°hÑ?Ô?Ñ@Ô@Ð@s   ¬5A" Á"
A/Á.A/c                 óp   — |                       t          j        t          |¦  «        g| j        ¢R Ž ¦  «        S r%  )rŸ   r   Úmpf_bernoullir/  r+  ©r„   r5  s     r…   rx   zMPContext.bernoulliü   s0   € Ø�|Š|�EÔ/µ°A±´ÐL¸Ô9KÐLÐLÐLÑMÔMÐMr‹   c                 óp   — |                       t          j        t          |¦  «        g| j        ¢R Ž ¦  «        S r%  )rŸ   r   Úmpf_zeta_intr/  r+  rR  s     r…   Ú	_zeta_intzMPContext._zeta_intÿ   s0   € Ø�|Š|�EÔ.­s°1©v¬vÐK¸Ô8JÐKÐKÐKÑLÔLÐLr‹   c                 óÀ   — |                       |¦  «        }|                       |¦  «        }|                      t          j        |j        |j        g| j        ¢R Ž ¦  «        S r%  )r(  rŸ   r   Ú	mpf_atan2r*  r+  )r„   r,  r&  s      r…   r}   zMPContext.atan2  sM   € Ø�KŠK˜‰NŒNˆØ�KŠK˜‰NŒNˆØ�|Š|�EœO¨A¬G°Q´WÐR¸sÔ?QÐRÐRÐRÑSÔSÐSr‹   c                 ó4  — |                       |¦  «        }t          |¦  «        }|                      |¦  «        r0|                      t	          j        ||j        g| j        ¢R Ž ¦  «        S |                      t	          j	        ||j
        g| j        ¢R Ž ¦  «        S r%  )r(  r/  Ú_is_real_typerŸ   r   Úmpf_psir*  r+  r¢   Úmpc_psir@  )r„   Úmr6  s      r…   r|   zMPContext.psi  s‰   € Ø�KŠK˜‰NŒNˆÝ�‰FŒFˆØ×Ò˜QÑÔð 	PØ—<’<¥¤¨a°´Ð N¸3Ô;MÐ NÐ NÐ NÑOÔOÐOà—<’<¥¤¨a°´Ð N¸3Ô;MÐ NÐ NÐ NÑOÔOÐOr‹   c                 ó   — t          |¦  «        | j        vr|                      |¦  «        }|                      |¦  «        \  }}t	          |d¦  «        rHt          j        |j        ||¦  «        \  }}|                      |¦  «        |                      |¦  «        fS t	          |d¦  «        rHt          j	        |j
        ||¦  «        \  }}|                      |¦  «        |                      |¦  «        fS  | j        |fi |¤Ž | j        |fi |¤ŽfS rE  )Útyperq   r(  Ú_parse_precr1  r   Úmpf_cos_sinr*  rŸ   Úmpc_cos_sinr@  r¢   rÂ   r¿   ©r„   r&  Úkwargsrˆ   r7  ÚcÚss          r…   Úcos_sinzMPContext.cos_sin  s  € Ý�‰7Œ7˜#œ)Ð#Ð#Ø—’˜A‘”ˆAØŸš¨Ñ0Ô0‰ˆˆhÝ�1�gÑÔð 	>ÝÔ$ Q¤W¨d°HÑ=Ô=‰DˆAˆqØ—<’< ‘?”? C§L¢L°¡O¤OÐ3Ð3Ý�Q˜Ñ Ô ð 	>ÝÔ$ Q¤W¨d°HÑ=Ô=‰DˆAˆqØ—<’< ‘?”? C§L¢L°¡O¤OÐ3Ð3à�3”7˜1Ð'Ð' Ð'Ð'¨¨¬°Ð)=Ð)=°fÐ)=Ð)=Ð=Ð=r‹   c                 ó   — t          |¦  «        | j        vr|                      |¦  «        }|                      |¦  «        \  }}t	          |d¦  «        rHt          j        |j        ||¦  «        \  }}|                      |¦  «        |                      |¦  «        fS t	          |d¦  «        rHt          j	        |j
        ||¦  «        \  }}|                      |¦  «        |                      |¦  «        fS  | j        |fi |¤Ž | j        |fi |¤ŽfS rE  )r^  rq   r(  r_  r1  r   Úmpf_cos_sin_pir*  rŸ   Úmpc_cos_sin_pir@  r¢   rÂ   r¿   rb  s          r…   Úcospi_sinpizMPContext.cospi_sinpi  s  € Ý�‰7Œ7˜#œ)Ð#Ð#Ø—’˜A‘”ˆAØŸš¨Ñ0Ô0‰ˆˆhÝ�1�gÑÔð 	>ÝÔ'¨¬°°xÑ@Ô@‰DˆAˆqØ—<’< ‘?”? C§L¢L°¡O¤OÐ3Ð3Ý�Q˜Ñ Ô ð 	>ÝÔ'¨¬°°xÑ@Ô@‰DˆAˆqØ—<’< ‘?”? C§L¢L°¡O¤OÐ3Ð3à�3”7˜1Ð'Ð' Ð'Ð'¨¨¬°Ð)=Ð)=°fÐ)=Ð)=Ð=Ð=r‹   c                 óF   — |                       ¦   «         }| j        |_        |S )zP
        Create a copy of the context, with the same working precision.
        )Ú	__class__rˆ   )r„   rL  s     r…   ÚclonezMPContext.clone)  s   € ð �MŠM‰OŒOˆØ”ˆŒØˆr‹   c                 óV   — t          |d¦  «        st          |¦  «        t          u rdS dS )Nr@  FT©r1  r^  Úcomplex©r„   r&  s     r…   rY  zMPContext._is_real_type4  s.   € Ý�1�gÑÔð 	¥$ q¡'¤'­WÐ"4Ð"4Ø�5Øˆtr‹   c                 óV   — t          |d¦  «        st          |¦  «        t          u rdS dS )Nr@  TFro  rq  s     r…   Ú_is_complex_typezMPContext._is_complex_type9  s.   € Ý�1�gÑÔð 	¥$ q¡'¤'­WÐ"4Ð"4Ø�4Øˆur‹   c                 ó’  — t          |d¦  «        r|j        t          k    S t          |d¦  «        rt          |j        v S t	          |t
          ¦  «        st	          |t          j        ¦  «        rdS |                      |¦  «        }t          |d¦  «        st          |d¦  «        r|  	                    |¦  «        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

        r*  r@  Fzisnan() needs a number as input)r1  r*  r#   r@  Ú
isinstancer   r^   rr   r(  ÚisnanÚ	TypeErrorrq  s     r…   rv  zMPContext.isnan>  s»   € õ" �1�gÑÔð 	#Ø”7�d’?Ð"Ý�1�gÑÔð 	#Ý˜1œ7�?Ð"Ý�a�Ñ#Ô#ð 	¥z°!µX´\Ñ'BÔ'Bð 	Ø�5Ø�KŠK˜‰NŒNˆÝ�1�gÑÔð 	 ¥'¨!¨WÑ"5Ô"5ð 	 Ø—9’9˜Q‘<”<ÐÝÐ9Ñ:Ô:Ð:r‹   c                 ó^   — |                       |¦  «        s|                      |¦  «        rdS dS )aè  
        Return *True* if *x* is a finite number, i.e. neither
        an infinity or a NaN.

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

        FT)Úisinfrv  rq  s     r…   ÚisfinitezMPContext.isfiniteZ  s1   € ð, �9Š9�Q‰<Œ<ð 	˜3Ÿ9š9 Q™<œ<ð 	Ø�5Øˆtr‹   c                 óœ  — |sdS t          |d¦  «        r|j        \  }}}}|o|dk    S t          |d¦  «        r"|j         o|                      |j        ¦  «        S t          |¦  «        t          v r|dk    S t          || j        ¦  «        r|j	        \  }}|sdS |dk    o|dk    S |                      |  
                    |¦  «        ¦  «        S )z<
        Determine if *x* is a nonpositive integer.
        Tr*  r   r@  r   )r1  r*  r9  Úisnpintr8  r^  r   ru  rr   Ú_mpq_r(  )r„   r&  ÚsignÚmanr¶   ÚbcÚpÚqs           r…   r|  zMPContext.isnpintt  sæ   € ð ð 	Ø�4Ý�1�gÑÔð 	%Ø!"¤ÑˆD�#�s˜BØÐ$˜C 1šHÐ$Ý�1�gÑÔð 	6Ø”v�:Ð5 #§+¢+¨a¬fÑ"5Ô"5Ð5Ý�‰7Œ7•iÐÐØ˜’6ˆMÝ�a˜œÑ!Ô!ð 	%Ø”7‰DˆAˆqØð Ø�tØ˜’6Ð$˜a 1šfÐ$Ø�{Š{˜3Ÿ;š; q™>œ>Ñ*Ô*Ð*r‹   c                 óì   — dd| j         z                       d¦  «        dz   d| j        z                       d¦  «        dz   d| j        z                       d¦  «        dz   g}d	                     |¦  «        S )
NzMpmath settings:z  mp.prec = %sé   z[default: 53]z  mp.dps = %sz[default: 15]z  mp.trap_complex = %sz[default: False]ú
)rˆ   ÚljustÚdpsrl   Újoin)r„   Úliness     r…   Ú__str__zMPContext.__str__ˆ  sy   € Ø#Ø ¤Ñ(×/Ò/°Ñ3Ô3°oÑEØ˜sœwÑ&×-Ò-¨bÑ1Ô1°OÑCØ%¨Ô(8Ñ8×?Ò?ÀÑCÔCÐFXÑXð
ˆð
 �yŠy˜ÑÔÐr‹   c                 ó*   — t          | j        ¦  «        S r%  )r   Ú_precrƒ   s    r…   Ú_repr_digitszMPContext._repr_digits�  s   € å˜œ	Ñ"Ô"Ð"r‹   c                 ó   — | j         S r%  )Ú_dpsrƒ   s    r…   Ú_str_digitszMPContext._str_digits”  s	   € àŒxˆr‹   Fc                 ó.   ‡— t          | ˆfd„d|¦  «        S )aÛ  
        The block

            with extraprec(n):
                <code>

        increases the precision n bits, executes <code>, and then
        restores the precision.

        extraprec(n)(f) returns a decorated version of the function f
        that increases the working precision by n bits before execution,
        and restores the parent precision afterwards. With
        normalize_output=True, it rounds the return value to the parent
        precision.
        c                 ó   •— | ‰z   S r%  © ©r�  r5  s    €r…   rŠ   z%MPContext.extraprec.<locals>.<lambda>¨  s   ø€ ¨q°1©u€ r‹   N©ÚPrecisionManager©r„   r5  Únormalize_outputs    ` r…   Ú	extrapreczMPContext.extraprec˜  s    ø€ õ     _ _ _ _°dÐ<LÑMÔMÐMr‹   c                 ó.   ‡— t          | dˆfd„|¦  «        S )z–
        This function is analogous to extraprec (see documentation)
        but changes the decimal precision instead of the number of bits.
        Nc                 ó   •— | ‰z   S r%  r“  ©Údr5  s    €r…   rŠ   z$MPContext.extradps.<locals>.<lambda>¯  s   ø€ °Q¸±U€ r‹   r•  r—  s    ` r…   ÚextradpszMPContext.extradpsª  s    ø€ õ
    T¨?¨?¨?¨?Ð<LÑMÔMÐMr‹   c                 ó.   ‡— t          | ˆfd„d|¦  «        S )a»  
        The block

            with workprec(n):
                <code>

        sets the precision to n bits, executes <code>, and then restores
        the precision.

        workprec(n)(f) returns a decorated version of the function f
        that sets the precision to n bits before execution,
        and restores the precision afterwards. With normalize_output=True,
        it rounds the return value to the parent precision.
        c                 ó   •— ‰S r%  r“  r”  s    €r…   rŠ   z$MPContext.workprec.<locals>.<lambda>À  s   ø€ ¨q€ r‹   Nr•  r—  s    ` r…   ÚworkpreczMPContext.workprec±  s    ø€ õ    [ [ [ [°$Ð8HÑIÔIÐIr‹   c                 ó.   ‡— t          | dˆfd„|¦  «        S )z•
        This function is analogous to workprec (see documentation)
        but changes the decimal precision instead of the number of bits.
        Nc                 ó   •— ‰S r%  r“  rœ  s    €r…   rŠ   z#MPContext.workdps.<locals>.<lambda>Ç  s   ø€ °Q€ r‹   r•  r—  s    ` r…   ÚworkdpszMPContext.workdpsÂ  s    ø€ õ
    T¨;¨;¨;¨;Ð8HÑIÔIÐIr‹   Nr“  c                 ó"   ‡ ‡‡‡‡— ˆˆ ˆˆˆfd„}|S )a‹
  
        Return a wrapped copy of *f* that repeatedly evaluates *f*
        with increasing precision until the result converges to the
        full precision used at the point of the call.

        This heuristically protects against rounding errors, at the cost of
        roughly a 2x slowdown compared to manually setting the optimal
        precision. This method can, however, easily be fooled if the results
        from *f* depend "discontinuously" on the precision, for instance
        if catastrophic cancellation can occur. Therefore, :func:`~mpmath.autoprec`
        should be used judiciously.

        **Examples**

        Many functions are sensitive to perturbations of the input arguments.
        If the arguments are decimal numbers, they may have to be converted
        to binary at a much higher precision. If the amount of required
        extra precision is unknown, :func:`~mpmath.autoprec` is convenient::

            >>> from mpmath import *
            >>> mp.dps = 15
            >>> mp.pretty = True
            >>> besselj(5, 125 * 10**28)    # Exact input
            -8.03284785591801e-17
            >>> besselj(5, '1.25e30')   # Bad
            7.12954868316652e-16
            >>> autoprec(besselj)(5, '1.25e30')   # Good
            -8.03284785591801e-17

        The following fails to converge because `\sin(\pi) = 0` whereas all
        finite-precision approximations of `\pi` give nonzero values::

            >>> autoprec(sin)(pi) # doctest: +IGNORE_EXCEPTION_DETAIL
            Traceback (most recent call last):
              ...
            NoConvergence: autoprec: prec increased to 2910 without convergence

        As the following example shows, :func:`~mpmath.autoprec` can protect against
        cancellation, but is fooled by too severe cancellation::

            >>> x = 1e-10
            >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
            1.00000008274037e-10
            1.00000000005e-10
            1.00000000005e-10
            >>> x = 1e-50
            >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
            0.0
            1.0e-50
            0.0

        With *catch*, an exception or list of exceptions to intercept
        may be specified. The raised exception is interpreted
        as signaling insufficient precision. This permits, for example,
        evaluating a function where a too low precision results in a
        division by zero::

            >>> f = lambda x: 1/(exp(x)-1)
            >>> f(1e-30)
            Traceback (most recent call last):
              ...
            ZeroDivisionError
            >>> autoprec(f, catch=ZeroDivisionError)(1e-30)
            1.0e+30


        c                  óP  •— ‰	j         }‰€‰	                     |¦  «        }n‰}	 |dz   ‰	_         	  ‰
| i |¤Ž}n# ‰$ r
 ‰	j        }Y nw xY w|dz   }	 |‰	_         	  ‰
| i |¤Ž}n# ‰$ r
 ‰	j        }Y nw xY w||k    rn—‰	                     ||z
  ¦  «        ‰	                     |¦  «        z
  }|| k     rna‰rt	          d|›d|›d| ›�¦  «         |}||k    r‰	                     d|z  ¦  «        ‚|t          |dz  ¦  «        z  }t          ||¦  «        }ŒÁ|‰	_         n# |‰	_         w xY w|
 S )	Né
   é   r   zautoprec: target=z, prec=z, accuracy=z2autoprec: prec increased to %i without convergenceé   )rˆ   Ú_default_hyper_maxprecr¦   ÚmagÚprintÚNoConvergencer/  Úmin)Úargsrc  rˆ   Úmaxprec2Úv1Úprec2Úv2ÚerrÚcatchr„   ÚfÚmaxprecÚverboses           €€€€€r…   Úf_autoprec_wrappedz.MPContext.autoprec.<locals>.f_autoprec_wrapped  s¾  ø€ Ø”8ˆDØˆØ×5Ò5°dÑ;Ô;��à"�ð Ø "™9�”ð!Ø˜˜DÐ+ FÐ+Ð+�B�BøØð !ð !ð !Øœ�B�B�Bð!øøøà˜r™	�ð1Ø$�C”Hð%Ø˜Q Ð/¨Ð/Ð/˜˜øØ ð %ð %ð %Ø œW˜˜˜ð%øøøà˜R’x�xØØŸ'š' " R¡%™.œ.¨3¯7ª7°2©;¬;Ñ6�CØ˜t˜e’}�}ØØð 3Ý˜Ø#˜t˜t U U U¨S¨D¨Dð2ñ 3ô 3ð 3à�BØ Ò(Ð(Ø!×/Ò/ØLØñ ñ!ô !ð !ð �S  q¡™\œ\Ñ)�EÝ  xÑ0Ô0�Eð)1ð,  �”�ø˜4�”����Ø�3ˆJsP   ¤
D ¯8 ·D ¸AÁD ÁAÁD ÁA! Á D Á!A0Á-D Á/A0Á0B!D Ä	D"r“  )r„   r¶  r·  rµ  r¸  r¹  s   ````` r…   ÚautopreczMPContext.autoprecÉ  s>   øøøøø€ ðH$	ð $	ð $	ð $	ð $	ð $	ð $	ð $	ð $	ðJ "Ð!r‹   é   c                 ó8  ‡ ‡‡— t          |t          ¦  «        r&dd                     ˆ ˆˆfd„|D ¦   «         ¦  «        z  S t          |t          ¦  «        r&dd                     ˆ ˆˆfd„|D ¦   «         ¦  «        z  S t	          |d¦  «        rt          |j        ‰fi ‰¤ŽS t	          |d¦  «        rdt          |j        ‰fi ‰¤Žz   d	z   S t          |t          ¦  «        rt          |¦  «        S t          |‰ j        ¦  «        r |j        ‰fi ‰¤ŽS t          |¦  «        S )
a3  
        Convert an ``mpf`` or ``mpc`` to a decimal string literal with *n*
        significant digits. The small default value for *n* is chosen to
        make this function useful for printing collections of numbers
        (lists, matrices, etc).

        If *x* is a list or tuple, :func:`~mpmath.nstr` is applied recursively
        to each element. For unrecognized classes, :func:`~mpmath.nstr`
        simply returns ``str(x)``.

        The companion function :func:`~mpmath.nprint` prints the result
        instead of returning it.

        The keyword arguments *strip_zeros*, *min_fixed*, *max_fixed*
        and *show_zero_exponent* are forwarded to :func:`~mpmath.libmp.to_str`.

        The number will be printed in fixed-point format if the position
        of the leading digit is strictly between min_fixed
        (default = min(-dps/3,-5)) and max_fixed (default = dps).

        To force fixed-point format always, set min_fixed = -inf,
        max_fixed = +inf. To force floating-point format, set
        min_fixed >= max_fixed.

            >>> from mpmath import *
            >>> nstr([+pi, ldexp(1,-500)])
            '[3.14159, 3.05494e-151]'
            >>> nprint([+pi, ldexp(1,-500)])
            [3.14159, 3.05494e-151]
            >>> nstr(mpf("5e-10"), 5)
            '5.0e-10'
            >>> nstr(mpf("5e-10"), 5, strip_zeros=False)
            '5.0000e-10'
            >>> nstr(mpf("5e-10"), 5, strip_zeros=False, min_fixed=-11)
            '0.00000000050000'
            >>> nstr(mpf(0), 5, show_zero_exponent=True)
            '0.0e+0'

        z[%s]z, c              3   ó6   •K  — | ]} ‰j         |‰fi ‰¤ŽV — Œd S r%  ©Únstr©Ú.0rd  r„   rc  r5  s     €€€r…   ú	<genexpr>z!MPContext.nstr.<locals>.<genexpr>]  ó9   øè è € Ð&KÐ&KÀA x s¤x°°1Ð'?Ð'?¸Ð'?Ð'?Ð&KÐ&KÐ&KÐ&KÐ&KÐ&Kr‹   z(%s)c              3   ó6   •K  — | ]} ‰j         |‰fi ‰¤ŽV — Œd S r%  r¾  rÀ  s     €€€r…   rÂ  z!MPContext.nstr.<locals>.<genexpr>_  rÃ  r‹   r*  r@  ú(ú))ru  Úlistrˆ  Útupler1  r   r*  r:   r@  r   ÚreprÚmatrixÚ__nstr__Ústr)r„   r&  r5  rc  s   ` ``r…   r¿  zMPContext.nstr4  sK  øøø€ õP �a�ÑÔð 	MØ˜TŸYšYÐ&KÐ&KÐ&KÐ&KÐ&KÐ&KÈÐ&KÑ&KÔ&KÑKÔKÑLÐLÝ�a�ÑÔð 	MØ˜TŸYšYÐ&KÐ&KÐ&KÐ&KÐ&KÐ&KÈÐ&KÑ&KÔ&KÑKÔKÑLÐLÝ�1�gÑÔð 	0Ý˜!œ' 1Ð/Ð/¨Ð/Ð/Ð/Ý�1�gÑÔð 	AØ� A¤G¨QÐ9Ð9°&Ð9Ð9Ñ9¸SÑ@Ð@Ý�a�Ñ$Ô$ð 	Ý˜‘7”7ˆNÝ�a˜œÑ$Ô$ð 	+Ø�1”:˜aÐ*Ð* 6Ð*Ð*Ð*Ý�1‰vŒvˆr‹   c                 ó   — |rêt          |t          ¦  «        rÕd|                     ¦   «         v r¿|                     ¦   «                              dd¦  «        }t                               |¦  «        }|                     d¦  «        }|sd}|                     d¦  «                             d¦  «        }|                      |  	                    |¦  «        |  	                    |¦  «        ¦  «        S t          |d¦  «        r4|j        \  }}||k    r|                      |¦  «        S t          d¦  «        ‚t          d	t          |¦  «        z   ¦  «        ‚)
Nr£   ú Ú Úrer   ÚimÚ_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )ru  r   ÚlowerÚreplaceÚget_complexÚmatchÚgroupÚrstripro   r(  r1  rÒ  rŸ   Ú
ValueErrorrw  rÉ  )r„   r&  ÚstringsrÖ  rÐ  rÑ  rL  rM  s           r…   Ú_convert_fallbackzMPContext._convert_fallbackj  s%  € Øð 	A•z !¥ZÑ0Ô0ð 	AØ�a—g’g‘i”iÐÐØ—G’G‘I”I×%Ò% c¨2Ñ.Ô.�Ý#×)Ò)¨!Ñ,Ô,�Ø—[’[ Ñ&Ô&�Øð Ø�BØ—[’[ Ñ&Ô&×-Ò-¨cÑ2Ô2�Ø—w’w˜sŸ{š{¨2™œ°·²¸B±´Ñ@Ô@Ð@Ý�1�gÑÔð 	QØ”7‰DˆAˆqØ�AŠvˆvØ—|’| A‘”Ð&å Ð!OÑPÔPÐPÝÐ1µD¸±G´GÑ;Ñ<Ô<Ð<r‹   c                 ó   —  | j         |i |¤ŽS r%  )r(  )r„   r¯  rc  s      r…   Ú	mpmathifyzMPContext.mpmathify|  s   € ØˆsŒ{˜DÐ+ FÐ+Ð+Ð+r‹   c                 ó  — |r‚|                      d¦  «        rdS | j        \  }}d|v r|d         }d|v r%|d         }|| j        k    rdS t          |¦  «        }n(d|v r$|d         }|| j        k    rdS t	          |¦  «        }||fS | j        S )NÚexact)r   r¶  r7  rˆ   r‡  )Úgetr+  r¤   r/  r   )r„   rc  rˆ   r7  r‡  s        r…   r_  zMPContext._parse_prec  s·   € Øð 	"Ø�zŠz˜'Ñ"Ô"ð Ø�vØ Ô/‰NˆD�(Ø˜VÐ#Ð#Ø! *Ô-�Ø˜ÐÐØ˜f”~�Ø˜3œ7’?�?Ø!˜6å˜t™9œ9�D�DØ˜&��Ø˜U”m�Ø˜#œ'’>�>Ø!˜6Ý" 3Ñ'Ô'�Ø˜�>Ð!ØÔ!Ð!r‹   z'the exact result does not fit in memoryzœhypsum() failed to converge to the requested %i bits of accuracy
using a working precision of %i bits. Try with a higher maxprec,
maxterms, or set zeroprec.Tc                 ó˜  — t          |d¦  «        r|||df}|j        }	nt          |d¦  «        r|||df}|j        }	|| j        vr"t	          j        |¦  «        d         | j        |<   | j        |         }
| j        }|                     d|                      |¦  «        ¦  «        }d}d}i }d	}t          |¦  «        D ]ç\  }}||         d
k    rW||k    rP|d	k    rJd}t          |d |…         ¦  «        D ]\  }}||         d
k    r|d	k    r||k    rd}Œ |st          d¦  «        ‚Œh|                      |¦  «        \  }}t          |¦  «         }| }||k    r<|d	k    r6|dk    r0||v r||xx         |z  cc<   n|||<   t          |||z
  dz   ¦  «        }|t          |¦  «        z  }Œè	 ||k    rt          | j        |||z   fz  ¦  «        ‚||z   }|rt#          d„ |D ¦   «         ¦  «        }ni } |
||	||||fi |¤Ž\  }}}| }d}||k     r#|                     ¦   «         D ]}|�||k     rd} nŒ||dz
  dz
  k     p| }|r>|rnK|                     d¦  «        } | �$|| k    r|r|                      d	¦  «        S | j        S |dz  }|dz  }|dz  }Œät+          |¦  «        t,          u r,|r|                      |¦  «        S |                      |¦  «        S |S )Nr*  ÚRr@  ÚCr   r·  é2   é   r   ÚZFTzpole in hypergeometric seriesé   é<   c              3   ó   K  — | ]}|d fV — Œ	d S r%  r“  )rÁ  r5  s     r…   rÂ  z#MPContext.hypsum.<locals>.<genexpr>Ç  s&   è è € ÐBÐB¨Q  4 ÐBÐBÐBÐBÐBÐBr‹   é   Úzeroprecr©  )r1  r*  r@  rv   r   Úmake_hyp_summatorrˆ   rà  rª  Ú	enumerateÚZeroDivisionErrorÚnint_distancer/  ÚmaxÚabsrÙ  Ú_hypsum_msgÚdictÚvaluesro   r¡   r^  rÈ  r¢   rŸ   )!r„   r�  r‚  ÚflagsÚcoeffsr6  Úaccurate_smallrc  ÚkeyrN  Úsummatorrˆ   r·  r™  ÚepsshiftÚmagnitude_checkÚmax_total_jumpÚird  ÚokÚiiÚccr5  r�  ÚwpÚmag_dictÚzvÚhave_complexÚ	magnitudeÚcancelÚjumps_resolvedÚaccuraterë  s!                                    r…   ÚhypsumzMPContext.hypsumš  sÃ  € Ý�1�gÑÔð 	Ø�Q˜˜sÐ"ˆCØ”ˆAˆAÝ�Q˜Ñ Ô ð 	Ø�Q˜˜sÐ"ˆCØ”ˆAØ�cÔ'Ð'Ð'Ý%*Ô%<¸SÑ%AÔ%AÀ!Ô%DˆCÔ˜cÑ"ØÔ$ SÔ)ˆØŒxˆØ—*’*˜Y¨×(BÒ(BÀ4Ñ(HÔ(HÑIÔIˆØˆ	Øˆð ˆØˆÝ˜fÑ%Ô%ð 	%ð 	%‰DˆAˆqØ�QŒx˜3ŠˆØ˜’6�6˜a 1šf˜fØ�BÝ"+¨F°2°A°2¬JÑ"7Ô"7ð &ð &™˜˜Bà  œ9¨Ò+Ð+°°a²°¸AÀºG¸GØ!%˜BøØð QÝ/Ð0OÑPÔPÐPØØ×$Ò$ QÑ'Ô'‰DˆAˆqÝ�Q‘”�ˆAØ�ˆAØ�AŠvˆv˜!˜qš&˜& Q¨¢U UØ˜Ð'Ð'Ø# AÐ&Ð&Ô&¨!Ñ+Ð&Ð&Ñ&Ð&à)*�O AÑ&Ý 	¨1¨t©8°b©=Ñ9Ô9�	Ø�c !™fœfÑ$ˆNˆNð#	Ø˜7Ò"Ð"Ý  ¤°D¸$¸y¹.Ð3IÑ!IÑJÔJÐJØ˜	Ñ!ˆBØð ÝÐBÐB°/ÐBÑBÔBÑBÔB��à�Ø*2¨(°6¸1¸dÀBØ˜(ð+.ð +.Ø&,ð+.ð +.Ñ'ˆB�˜ià�ZˆFØ!ˆNØ˜>Ò)Ð)Ø!ŸšÑ*Ô*ð ð �AØ˜	 q¨4¢x xØ).˜Ø˜ð (0ð  ¨2¡¨a¡Ò/ÐE°~Ð3EˆHØð 
,Øð Øà!Ÿ:š: jÑ1Ô1�ØÐ'Ø Ò(Ð(Ø'ð ,Ø#&§7¢7¨1¡:¤:Ð-à#&¤8˜Oð ˜‰NˆIà˜‰MˆHØ˜‰NˆIðG#	õJ �‰8Œ8•uÐÐØð (Ø—|’| BÑ'Ô'Ð'à—|’| BÑ'Ô'Ð'àˆIr‹   c                 ó†   — |                       |¦  «        }|                      t          j        |j        |¦  «        ¦  «        S )a–  
        Computes `x 2^n` efficiently. No rounding is performed.
        The argument `x` must be a real floating-point number (or
        possible to convert into one) and `n` must be a Python ``int``.

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> ldexp(1, 10)
            mpf('1024.0')
            >>> ldexp(1, -3)
            mpf('0.125')

        )r(  rŸ   r   Ú	mpf_shiftr*  rB  s      r…   ÚldexpzMPContext.ldexpï  s3   € ð �KŠK˜‰NŒNˆØ�|Š|�EœO¨A¬G°QÑ7Ô7Ñ8Ô8Ð8r‹   c                 ó’   — |                       |¦  «        }t          j        |j        ¦  «        \  }}|                      |¦  «        |fS )a=  
        Given a real number `x`, returns `(y, n)` with `y \in [0.5, 1)`,
        `n` a Python integer, and such that `x = y 2^n`. No rounding is
        performed.

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> frexp(7.5)
            (mpf('0.9375'), 3)

        )r(  r   Ú	mpf_frexpr*  rŸ   )r„   r&  r,  r5  s       r…   ÚfrexpzMPContext.frexp   s=   € ð �KŠK˜‰NŒNˆÝŒ˜qœwÑ'Ô'‰ˆˆ1Ø�|Š|˜A‰Œ Ð!Ð!r‹   c                 ó^  — |                       |¦  «        \  }}|                      |¦  «        }t          |d¦  «        r)|                      t	          |j        ||¦  «        ¦  «        S t          |d¦  «        r)|                      t          |j        ||¦  «        ¦  «        S t          d¦  «        ‚)a�  
        Negates the number *x*, giving a floating-point result, optionally
        using a custom precision and rounding mode.

        See the documentation of :func:`~mpmath.fadd` for a detailed description
        of how to specify precision and rounding.

        **Examples**

        An mpmath number is returned::

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fneg(2.5)
            mpf('-2.5')
            >>> fneg(-5+2j)
            mpc(real='5.0', imag='-2.0')

        Precise control over rounding is possible::

            >>> x = fadd(2, 1e-100, exact=True)
            >>> fneg(x)
            mpf('-2.0')
            >>> fneg(x, rounding='f')
            mpf('-2.0000000000000004')

        Negating with and without roundoff::

            >>> n = 200000000000000000000001
            >>> print(int(-mpf(n)))
            -200000000000000016777216
            >>> print(int(fneg(n)))
            -200000000000000016777216
            >>> print(int(fneg(n, prec=log(n,2)+1)))
            -200000000000000000000001
            >>> print(int(fneg(n, dps=log(n,10)+1)))
            -200000000000000000000001
            >>> print(int(fneg(n, prec=inf)))
            -200000000000000000000001
            >>> print(int(fneg(n, dps=inf)))
            -200000000000000000000001
            >>> print(int(fneg(n, exact=True)))
            -200000000000000000000001

        r*  r@  ú2Arguments need to be mpf or mpc compatible numbers)
r_  r(  r1  rŸ   r&   r*  r¢   r?   r@  rÙ  )r„   r&  rc  rˆ   r7  s        r…   ÚfnegzMPContext.fneg  sž   € ð\ Ÿš¨Ñ0Ô0‰ˆˆhØ�KŠK˜‰NŒNˆÝ�1�gÑÔð 	BØ—<’<¥¨¬°°xÑ @Ô @ÑAÔAÐAÝ�1�gÑÔð 	BØ—<’<¥¨¬°°xÑ @Ô @ÑAÔAÐAÝÐMÑNÔNÐNr‹   c                 ó2  — |                       |¦  «        \  }}|                      |¦  «        }|                      |¦  «        }	 t          |d¦  «        r~t          |d¦  «        r/|                      t	          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r~t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S n)# t          t          f$ r t          | j        ¦  «        ‚w xY wt          d¦  «        ‚)a“  
        Adds the numbers *x* and *y*, giving a floating-point result,
        optionally using a custom precision and rounding mode.

        The default precision is the working precision of the context.
        You can specify a custom precision in bits by passing the *prec* keyword
        argument, or by providing an equivalent decimal precision with the *dps*
        keyword argument. If the precision is set to ``+inf``, or if the flag
        *exact=True* is passed, an exact addition with no rounding is performed.

        When the precision is finite, the optional *rounding* keyword argument
        specifies the direction of rounding. Valid options are ``'n'`` for
        nearest (default), ``'f'`` for floor, ``'c'`` for ceiling, ``'d'``
        for down, ``'u'`` for up.

        **Examples**

        Using :func:`~mpmath.fadd` with precision and rounding control::

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fadd(2, 1e-20)
            mpf('2.0')
            >>> fadd(2, 1e-20, rounding='u')
            mpf('2.0000000000000004')
            >>> nprint(fadd(2, 1e-20, prec=100), 25)
            2.00000000000000000001
            >>> nprint(fadd(2, 1e-20, dps=15), 25)
            2.0
            >>> nprint(fadd(2, 1e-20, dps=25), 25)
            2.00000000000000000001
            >>> nprint(fadd(2, 1e-20, exact=True), 25)
            2.00000000000000000001

        Exact addition avoids cancellation errors, enforcing familiar laws
        of numbers such as `x+y-x = y`, which don't hold in floating-point
        arithmetic with finite precision::

            >>> x, y = mpf(2), mpf('1e-1000')
            >>> print(x + y - x)
            0.0
            >>> print(fadd(x, y, prec=inf) - x)
            1.0e-1000
            >>> print(fadd(x, y, exact=True) - x)
            1.0e-1000

        Exact addition can be inefficient and may be impossible to perform
        with large magnitude differences::

            >>> fadd(1, '1e-100000000000000000000', prec=inf)
            Traceback (most recent call last):
              ...
            OverflowError: the exact result does not fit in memory

        r*  r@  r  )r_  r(  r1  rŸ   r'   r*  r¢   rC   r@  rB   rÙ  ÚOverflowErrorÚ_exact_overflow_msg©r„   r&  r,  rc  rˆ   r7  s         r…   ÚfaddzMPContext.faddF  s€  € ðp Ÿš¨Ñ0Ô0‰ˆˆhØ�KŠK˜‰NŒNˆØ�KŠK˜‰NŒNˆð	9Ý�q˜'Ñ"Ô"ð WÝ˜1˜gÑ&Ô&ð SØŸ<š<­°´¸¼À$ÈÑ(QÔ(QÑRÔRÐRÝ˜1˜gÑ&Ô&ð WØŸ<š<­°A´G¸Q¼WÀdÈHÑ(UÔ(UÑVÔVÐVÝ�q˜'Ñ"Ô"ð SÝ˜1˜gÑ&Ô&ð WØŸ<š<­°A´G¸Q¼WÀdÈHÑ(UÔ(UÑVÔVÐVÝ˜1˜gÑ&Ô&ð SØŸ<š<­°´¸¼À$ÈÑ(QÔ(QÑRÔRÐRøøÝ�MÐ*ð 	9ð 	9ð 	9Ý Ô 7Ñ8Ô8Ð8ð	9øøøåÐMÑNÔNÐNó    ÁAE! Â>E! ÃAE! Ä!>E! Å!&Fc                 ó@  — |                       |¦  «        \  }}|                      |¦  «        }|                      |¦  «        }	 t          |d¦  «        r…t          |d¦  «        r/|                      t	          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r6|                      t          |j        t          f|j	        ||¦  «        ¦  «        S t          |d¦  «        r~t          |d¦  «        r/|                      t          |j	        |j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          |j	        |j	        ||¦  «        ¦  «        S n)# t          t          f$ r t          | j        ¦  «        ‚w xY wt          d¦  «        ‚)a�  
        Subtracts the numbers *x* and *y*, giving a floating-point result,
        optionally using a custom precision and rounding mode.

        See the documentation of :func:`~mpmath.fadd` for a detailed description
        of how to specify precision and rounding.

        **Examples**

        Using :func:`~mpmath.fsub` with precision and rounding control::

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fsub(2, 1e-20)
            mpf('2.0')
            >>> fsub(2, 1e-20, rounding='d')
            mpf('1.9999999999999998')
            >>> nprint(fsub(2, 1e-20, prec=100), 25)
            1.99999999999999999999
            >>> nprint(fsub(2, 1e-20, dps=15), 25)
            2.0
            >>> nprint(fsub(2, 1e-20, dps=25), 25)
            1.99999999999999999999
            >>> nprint(fsub(2, 1e-20, exact=True), 25)
            1.99999999999999999999

        Exact subtraction avoids cancellation errors, enforcing familiar laws
        of numbers such as `x-y+y = x`, which don't hold in floating-point
        arithmetic with finite precision::

            >>> x, y = mpf(2), mpf('1e1000')
            >>> print(x - y + y)
            0.0
            >>> print(fsub(x, y, prec=inf) + y)
            2.0
            >>> print(fsub(x, y, exact=True) + y)
            2.0

        Exact addition can be inefficient and may be impossible to perform
        with large magnitude differences::

            >>> fsub(1, '1e-100000000000000000000', prec=inf)
            Traceback (most recent call last):
              ...
            OverflowError: the exact result does not fit in memory

        r*  r@  r  )r_  r(  r1  rŸ   r(   r*  r¢   rD   r    r@  rE   rÙ  r  r  r  s         r…   ÚfsubzMPContext.fsub�  s†  € ð` Ÿš¨Ñ0Ô0‰ˆˆhØ�KŠK˜‰NŒNˆØ�KŠK˜‰NŒNˆð	9Ý�q˜'Ñ"Ô"ð \Ý˜1˜gÑ&Ô&ð SØŸ<š<­°´¸¼À$ÈÑ(QÔ(QÑRÔRÐRÝ˜1˜gÑ&Ô&ð \ØŸ<š<­°´½%Ð0@À!Ä'È4ÐQYÑ(ZÔ(ZÑ[Ô[Ð[Ý�q˜'Ñ"Ô"ð SÝ˜1˜gÑ&Ô&ð WØŸ<š<­°A´G¸Q¼WÀdÈHÑ(UÔ(UÑVÔVÐVÝ˜1˜gÑ&Ô&ð SØŸ<š<­°´¸¼À$ÈÑ(QÔ(QÑRÔRÐRøøÝ�MÐ*ð 	9ð 	9ð 	9Ý Ô 7Ñ8Ô8Ð8ð	9øøøåÐMÑNÔNÐNs!   ÁAE( ÂAE( ÃAE( Ä(>E( Å(&Fc                 ó2  — |                       |¦  «        \  }}|                      |¦  «        }|                      |¦  «        }	 t          |d¦  «        r~t          |d¦  «        r/|                      t	          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r~t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S n)# t          t          f$ r t          | j        ¦  «        ‚w xY wt          d¦  «        ‚)a¥  
        Multiplies the numbers *x* and *y*, giving a floating-point result,
        optionally using a custom precision and rounding mode.

        See the documentation of :func:`~mpmath.fadd` for a detailed description
        of how to specify precision and rounding.

        **Examples**

        The result is an mpmath number::

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fmul(2, 5.0)
            mpf('10.0')
            >>> fmul(0.5j, 0.5)
            mpc(real='0.0', imag='0.25')

        Avoiding roundoff::

            >>> x, y = 10**10+1, 10**15+1
            >>> print(x*y)
            10000000001000010000000001
            >>> print(mpf(x) * mpf(y))
            1.0000000001e+25
            >>> print(int(mpf(x) * mpf(y)))
            10000000001000011026399232
            >>> print(int(fmul(x, y)))
            10000000001000011026399232
            >>> print(int(fmul(x, y, dps=25)))
            10000000001000010000000001
            >>> print(int(fmul(x, y, exact=True)))
            10000000001000010000000001

        Exact multiplication with complex numbers can be inefficient and may
        be impossible to perform with large magnitude differences between
        real and imaginary parts::

            >>> x = 1+2j
            >>> y = mpc(2, '1e-100000000000000000000')
            >>> fmul(x, y)
            mpc(real='2.0', imag='4.0')
            >>> fmul(x, y, rounding='u')
            mpc(real='2.0', imag='4.0000000000000009')
            >>> fmul(x, y, exact=True)
            Traceback (most recent call last):
              ...
            OverflowError: the exact result does not fit in memory

        r*  r@  r  )r_  r(  r1  rŸ   r)   r*  r¢   rG   r@  rF   rÙ  r  r  r  s         r…   ÚfmulzMPContext.fmulÒ  s€  € ðf Ÿš¨Ñ0Ô0‰ˆˆhØ�KŠK˜‰NŒNˆØ�KŠK˜‰NŒNˆð	9Ý�q˜'Ñ"Ô"ð WÝ˜1˜gÑ&Ô&ð SØŸ<š<­°´¸¼À$ÈÑ(QÔ(QÑRÔRÐRÝ˜1˜gÑ&Ô&ð WØŸ<š<­°A´G¸Q¼WÀdÈHÑ(UÔ(UÑVÔVÐVÝ�q˜'Ñ"Ô"ð SÝ˜1˜gÑ&Ô&ð WØŸ<š<­°A´G¸Q¼WÀdÈHÑ(UÔ(UÑVÔVÐVÝ˜1˜gÑ&Ô&ð SØŸ<š<­°´¸¼À$ÈÑ(QÔ(QÑRÔRÐRøøÝ�MÐ*ð 	9ð 	9ð 	9Ý Ô 7Ñ8Ô8Ð8ð	9øøøåÐMÑNÔNÐNr  c                 ó  — |                       |¦  «        \  }}|st          d¦  «        ‚|                      |¦  «        }|                      |¦  «        }t          |d¦  «        r…t          |d¦  «        r/|                      t          |j        |j        ||¦  «        ¦  «        S t          |d¦  «        r6|                      t          |j        t          f|j
        ||¦  «        ¦  «        S t          |d¦  «        r~t          |d¦  «        r/|                      t          |j
        |j        ||¦  «        ¦  «        S t          |d¦  «        r/|                      t          |j
        |j
        ||¦  «        ¦  «        S t          d¦  «        ‚)a©  
        Divides the numbers *x* and *y*, giving a floating-point result,
        optionally using a custom precision and rounding mode.

        See the documentation of :func:`~mpmath.fadd` for a detailed description
        of how to specify precision and rounding.

        **Examples**

        The result is an mpmath number::

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fdiv(3, 2)
            mpf('1.5')
            >>> fdiv(2, 3)
            mpf('0.66666666666666663')
            >>> fdiv(2+4j, 0.5)
            mpc(real='4.0', imag='8.0')

        The rounding direction and precision can be controlled::

            >>> fdiv(2, 3, dps=3)    # Should be accurate to at least 3 digits
            mpf('0.6666259765625')
            >>> fdiv(2, 3, rounding='d')
            mpf('0.66666666666666663')
            >>> fdiv(2, 3, prec=60)
            mpf('0.66666666666666667')
            >>> fdiv(2, 3, rounding='u')
            mpf('0.66666666666666674')

        Checking the error of a division by performing it at higher precision::

            >>> fdiv(2, 3) - fdiv(2, 3, prec=100)
            mpf('-3.7007434154172148e-17')

        Unlike :func:`~mpmath.fadd`, :func:`~mpmath.fmul`, etc., exact division is not
        allowed since the quotient of two floating-point numbers generally
        does not have an exact floating-point representation. (In the
        future this might be changed to allow the case where the division
        is actually exact.)

            >>> fdiv(2, 3, exact=True)
            Traceback (most recent call last):
              ...
            ValueError: division is not an exact operation

        z"division is not an exact operationr*  r@  r  )r_  rÙ  r(  r1  rŸ   r+   r*  r¢   rI   r    r@  rJ   r  s         r…   ÚfdivzMPContext.fdiv  sf  € ðb Ÿš¨Ñ0Ô0‰ˆˆhØð 	CÝÐAÑBÔBÐBØ�KŠK˜‰NŒNˆØ�KŠK˜‰NŒNˆÝ�1�gÑÔð 	XÝ�q˜'Ñ"Ô"ð OØ—|’|¥G¨A¬G°Q´W¸dÀHÑ$MÔ$MÑNÔNÐNÝ�q˜'Ñ"Ô"ð XØ—|’|¥G¨Q¬WµeÐ,<¸a¼gÀtÈXÑ$VÔ$VÑWÔWÐWÝ�1�gÑÔð 	OÝ�q˜'Ñ"Ô"ð SØ—|’|¥K°´¸¼À$ÈÑ$QÔ$QÑRÔRÐRÝ�q˜'Ñ"Ô"ð OØ—|’|¥G¨A¬G°Q´W¸dÀHÑ$MÔ$MÑNÔNÐNÝÐMÑNÔNÐNr‹   c                 óF  — t          |¦  «        }|t          v rt          |¦  «        | j        fS |t          j        u rm|j        \  }}t          ||¦  «        \  }}d|z  |k    r|dz  }n|s	|| j        fS t          t          |||z  z
  ¦  «        ¦  «        t          |¦  «        z
  }||fS t          |d¦  «        r|j        }| j        }	n¤t          |d¦  «        r;|j        \  }}
|
\  }}}}|r||z   }	n{|
t          k    r| j        }	nht          d¦  «        ‚|                      |¦  «        }t          |d¦  «        st          |d¦  «        r|                      |¦  «        S t#          d¦  «        ‚|\  }}}}||z   }|dk     rd}|}n�|rg|dk    r||z  }| j        }nN|dk    r|dz	  dz   }d}n=| dz
  }||z	  }|dz  r|dz  }||z  |z
  }n|||z  z  }|dz	  }|t          |¦  «        z   }|r| }n$|t          k    r
| j        }d}nt          d¦  «        ‚|t%          ||	¦  «        fS )	aº  
        Return `(n,d)` where `n` is the nearest integer to `x` and `d` is
        an estimate of `\log_2(|x-n|)`. If `d < 0`, `-d` gives the precision
        (measured in bits) lost to cancellation when computing `x-n`.

            >>> from mpmath import *
            >>> n, d = nint_distance(5)
            >>> print(n); print(d)
            5
            -inf
            >>> n, d = nint_distance(mpf(5))
            >>> print(n); print(d)
            5
            -inf
            >>> n, d = nint_distance(mpf(5.00000001))
            >>> print(n); print(d)
            5
            -26
            >>> n, d = nint_distance(mpf(4.99999999))
            >>> print(n); print(d)
            5
            -26
            >>> n, d = nint_distance(mpc(5,10))
            >>> print(n); print(d)
            5
            4
            >>> n, d = nint_distance(mpc(5,0.000001))
            >>> print(n); print(d)
            5
            -19

        r©  r   r*  r@  zrequires a finite numberzrequires an mpf/mpcr   éÿÿÿÿ)r^  r   r/  r¥   r^   rr   r}  Údivmodr8   rñ  r1  r*  r@  r    rÙ  r(  rï  rw  rð  )r„   r&  Útypxr�  r‚  r5  Úrr�  rÐ  Úim_distrÑ  ÚisignÚimanÚiexpÚibcr~  r  r¶   r€  r«  Úre_distÚts                         r…   rï  zMPContext.nint_distanceY  s�  € õB �A‰wŒwˆØ•9ÐÐÝ�q‘6”6˜3œ8Ð#Ð#Ø•X”\Ð!Ð!Ø”7‰DˆAˆqÝ˜!˜Q‘<”<‰DˆAˆqØ�‰s�aŠxˆxØ�Q‘��Øð #Ø˜#œ(�{Ð"å�˜Q˜q ™s™U™œÑ$Ô$¥x°¡{¤{Ñ2ˆAØ�a�4ˆKÝ�1�gÑÔð 	7Ø”ˆBØ”hˆGˆGÝ�Q˜Ñ Ô ð 	7Ø”W‰FˆB�Ø%'Ñ"ˆE�4˜˜sØð =Ø ™*��Ø•u’�Øœ(��å Ð!;Ñ<Ô<Ð<à—’˜A‘”ˆAÝ�q˜'Ñ"Ô"ð 7¥g¨a°Ñ&9Ô&9ð 7Ø×(Ò(¨Ñ+Ô+Ð+åÐ 5Ñ6Ô6Ð6ØÑˆˆc�3˜Ø�"‰fˆà�Š7ˆ7ØˆAØˆGˆGØð 	9à�aŠxˆxØ˜3‘J�Øœ(��à˜’�Ø˜!‘V˜Q‘J�Ø��à�T˜!‘V�Ø˜1‘H�Ø�q‘5ð "Ø˜‘F�AØ˜a™4 3™,�C�Cà˜A˜q™D‘M�CØ�q‘D�Ø�h s™mœmÑ+�Øð Ø�B�øØ•5Š[ˆ[Ø”hˆGØˆAˆAåÐ7Ñ8Ô8Ð8Ø•#�g˜wÑ'Ô'Ð'Ð'r‹   c                 ód   — | j         }	 | j        }|D ]}||z  }Œ	 || _         n# || _         w xY w|
 S )aT  
        Calculates a product containing a finite number of factors (for
        infinite products, see :func:`~mpmath.nprod`). The factors will be
        converted to mpmath numbers.

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

        )rˆ   r    )r„   ÚfactorsÚorigrN  r�  s        r…   ÚfprodzMPContext.fprod»  sW   € ð Œxˆð	Ø”ˆAØð ð �Ø�Q‘��ðð ˆCŒHˆHø�tˆCŒHˆOˆOˆOˆOØˆrˆ	s   ‰# £	,c                 óP   — |                       t          | j        ¦  «        ¦  «        S )z·
        Returns an ``mpf`` with value chosen randomly from `[0, 1)`.
        The number of randomly generated bits in the mantissa is equal
        to the working precision.
        )rŸ   r6   rŒ  rƒ   s    r…   ÚrandzMPContext.randÐ  s    € ð �|Š|�H S¤YÑ/Ô/Ñ0Ô0Ð0r‹   c                 óD   ‡‡— |                       ˆˆfd„‰›d‰›�¦  «        S )a  
        Given Python integers `(p, q)`, returns a lazy ``mpf`` representing
        the fraction `p/q`. The value is updated with the precision.

            >>> from mpmath import *
            >>> mp.dps = 15
            >>> a = fraction(1,100)
            >>> b = mpf(1)/100
            >>> print(a); print(b)
            0.01
            0.01
            >>> mp.dps = 30
            >>> print(a); print(b)      # a will be accurate
            0.01
            0.0100000000000000002081668171172
            >>> mp.dps = 15
        c                 ó(   •— t          ‰‰| |¦  «        S r%  )r   )rˆ   r‰   r�  r‚  s     €€r…   rŠ   z$MPContext.fraction.<locals>.<lambda>ê  s   ø€ ­m¸A¸qÀ$ÈÑ.LÔ.L€ r‹   ú/)rp   )r„   r�  r‚  s    ``r…   ÚfractionzMPContext.fractionØ  s9   øø€ ð$ �|Š|ÐLÐLÐLÐLÐLØ�q�q˜!˜!Ðñô ð 	r‹   c                 óF   — t          |                      |¦  «        ¦  «        S r%  ©rñ  r(  rq  s     r…   ÚabsminzMPContext.absminí  ó   € Ý�3—;’;˜q‘>”>Ñ"Ô"Ð"r‹   c                 óF   — t          |                      |¦  «        ¦  «        S r%  r6  rq  s     r…   ÚabsmaxzMPContext.absmaxð  r8  r‹   c                 óŽ   — t          |d¦  «        r4|j        \  }}|                      |¦  «        |                      |¦  «        gS |S )NrÒ  )r1  rÒ  rŸ   )r„   r&  rL  rM  s       r…   Ú
_as_pointszMPContext._as_pointsó  sC   € å�1�gÑÔð 	6Ø”7‰DˆAˆqØ—L’L ‘O”O S§\¢\°!¡_¤_Ð5Ð5Øˆr‹   r   c                 ó
  ‡ — ‰                       |¦  «        rt          |d¦  «        st          ‚t          |¦  «        }‰ j        }t          j        |j        |||||¦  «        \  }}ˆ fd„|D ¦   «         }ˆ fd„|D ¦   «         }||fS )Nr@  c                 ó:   •— g | ]}‰                      |¦  «        ‘ŒS r“  ©r¢   )rÁ  r&  r„   s     €r…   ú
<listcomp>z+MPContext._zetasum_fast.<locals>.<listcomp>  ó#   ø€ Ð*Ð*Ð* !ˆc�lŠl˜1‰oŒoÐ*Ð*Ð*r‹   c                 ó:   •— g | ]}‰                      |¦  «        ‘ŒS r“  r?  )rÁ  r,  r„   s     €r…   r@  z+MPContext._zetasum_fast.<locals>.<listcomp>  rA  r‹   )Úisintr1  r2  r/  rŒ  r   Úmpc_zetasumr@  )	r„   re  rL  r5  ÚderivativesÚreflectrˆ   ÚxsÚyss	   `        r…   Ú_zetasum_fastzMPContext._zetasum_fast  s™   ø€ Ø—	’	˜!‘”ð 	&¥¨¨GÑ!4Ô!4ð 	&Ý%Ð%Ý�‰FŒFˆØŒyˆÝÔ" 1¤7¨A¨q°+¸wÈÑMÔM‰ˆˆBØ*Ð*Ð*Ð* rÐ*Ñ*Ô*ˆØ*Ð*Ð*Ð* rÐ*Ñ*Ô*ˆØ�2ˆvˆr‹   )r   ©F)Nr“  F)r»  )T)8Ú__name__Ú
__module__Ú__qualname__Ú__doc__rk   ru   r9   r-  r:  r<  rC  rH  rO  rx   rU  r}   r|   rf  rj  rm  rY  rs  rv  rz  r|  rŠ  Úpropertyr�  r�  r™  rž  r¡  r¤  rº  r¿  rÛ  rÝ  r_  r  rò  r	  r  r  r  r  r  r  r  rï  r.  r0  r4  r7  r:  r<  rI  r“  r‹   r…   rg   rg   :   s½  € € € € € ðð ð1ð 1ð 1ðBT5ð T5ð T5ðl ð  ð  ðTð Tð Tð.ð .ð .ð.ð .ð .ð
Jð 
Jð 
JðPð Pð PðAð Að Að AðNð Nð NðMð Mð MðTð Tð Tð
Pð Pð Pð>ð >ð >ð>ð >ð >ðð ð ðð ð ð
ð ð ð
;ð ;ð ;ð8ð ð ð4+ð +ð +ð( ð  ð  ð ð#ð #ñ „Xð#ð ðð ñ „XððNð Nð Nð Nð$Nð Nð Nð NðJð Jð Jð Jð"Jð Jð Jð Jði"ð i"ð i"ð i"ðV4ð 4ð 4ð 4ðl=ð =ð =ð$,ð ,ð ,ð"ð "ð "ð* DÐð€KðSð Sð Sð Sðj9ð 9ð 9ð""ð "ð "ð 4Oð 4Oð 4OðlHOð HOð HOðT@Oð @Oð @OðDCOð COð COðJ@Oð @Oð @OðD`(ð `(ð `(ðDð ð ð*1ð 1ð 1ðð ð ð*#ð #ð #ð#ð #ð #ðð ð ðð" 23°¸Uð ð ð ð ð ð r‹   rg   c                   ó(   — e Zd Zdd„Zd„ Zd„ Zd„ ZdS )r–  Fc                 ó>   — || _         || _        || _        || _        d S r%  )r„   ÚprecfunÚdpsfunr˜  )Úselfr„   rR  rS  r˜  s        r…   rk   zPrecisionManager.__init__  s%   € ØˆŒØˆŒØˆŒØ 0ˆÔÐÐr‹   c                 óJ   ‡ ‡— t          j        ‰¦  «        ˆˆ fd„¦   «         }|S )Nc                  óÎ  •— ‰j         j        }	 ‰j        r*‰                     ‰j         j        ¦  «        ‰j         _        n)‰                     ‰j         j        ¦  «        ‰j         _        ‰j        rR ‰| i |¤Ž}t          |¦  «        t          u r%t          d„ |D ¦   «         ¦  «        |‰j         _        S |
 |‰j         _        S  ‰| i |¤Ž|‰j         _        S # |‰j         _        w xY w)Nc                 ó   — g | ]}|
 ‘ŒS r“  r“  )rÁ  rL  s     r…   r@  z8PrecisionManager.__call__.<locals>.g.<locals>.<listcomp>'  s   €  _ _ _¨Q q b _ _ _r‹   )r„   rˆ   rR  rS  r‡  r˜  r^  rÈ  )r¯  rc  r-  rN  r¶  rT  s       €€r…   Úgz$PrecisionManager.__call__.<locals>.g  sé   ø€ à”8”=ˆDð%Ø”<ð =Ø$(§L¢L°´´Ñ$?Ô$?�D”H”M�Mà#'§;¢;¨t¬x¬|Ñ#<Ô#<�D”H”LØÔ(ð .Ø˜˜4Ð* 6Ð*Ð*�AÝ˜A‘w”w¥%Ð'Ð'Ý$ _ _°! _¡_¤_Ñ5Ô5ð
 !%�””�ð	 ˜2ð !%�””�ð ˜1˜dÐ- fÐ-Ð-à $�””�ø �””Ð$Ð$Ð$Ð$s   �BC Â3C ÃC ÃC$)Ú	functoolsÚwraps)rT  r¶  rX  s   `` r…   Ú__call__zPrecisionManager.__call__  s>   øø€ Ý	Œ˜Ñ	Ô	ð	%ð 	%ð 	%ð 	%ð 	%ñ 
Ô	ð	%ð  ˆr‹   c                 óÞ   — | j         j        | _        | j        r+|                      | j         j        ¦  «        | j         _        d S |                      | j         j        ¦  «        | j         _        d S r%  )r„   rˆ   ÚorigprR  rS  r‡  )rT  s    r…   Ú	__enter__zPrecisionManager.__enter__.  sQ   € Ø”X”]ˆŒ
ØŒ<ð 	5Ø ŸLšL¨¬¬Ñ7Ô7ˆDŒHŒMˆMˆMàŸ;š; t¤x¤|Ñ4Ô4ˆDŒHŒLˆLˆLr‹   c                 ó(   — | j         | j        _        dS ri   )r]  r„   rˆ   )rT  Úexc_typeÚexc_valÚexc_tbs       r…   Ú__exit__zPrecisionManager.__exit__4  s   € Øœ
ˆŒŒØˆur‹   NrJ  )rK  rL  rM  rk   r[  r^  rc  r“  r‹   r…   r–  r–    sU   € € € € € ð1ð 1ð 1ð 1ð
ð ð ð&5ð 5ð 5ðð ð ð ð r‹   r–  Ú__main__)wrN  Ú__docformat__rY  rÐ  Úctx_baser   Úlibmp.backendr   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^   ÚobjectÚ__new__ÚnewÚcompilerÕ  Úsage.libs.mpmath.ext_mainr`   rj   ÚlibsÚmpmathÚext_mainÚ_mpf_modulerb   ra   rc   rd   re   rg   r–  rK  ÚdoctestÚtestmodr“  r‹   r…   ú<module>rs     s0  ððð ð €à Ð Ð Ð à 	€	€	€	à )Ð )Ð )Ð )Ð )Ð )à .Ð .Ð .Ð .Ð .Ð .Ð .Ð .à Ð Ð Ð Ð Ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð. Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð à„n€àˆbŒjð Kñ Lô L€ð ˆfÒÐØBÐBÐBÐBÐBÐBà3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3Ð3à?Ð?Ð?Ð?Ð?Ð?Ø.Ð.Ð.Ð.Ð.Ð.à 0Ð 0Ð 0Ð 0Ð 0Ð 0Ð 0Ð 0Ð 0Ð 0ðYð Yð Yð Yð Y�Ð2ñ Yô Yð Yðv&!ð !ð !ð !ð !ñ !ô !ð !ðH ˆzÒÐØ€N€N€NØ€G„OÑÔÐÐÐð Ðr‹   