o
     ôj,Á  ã                   @   s`  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` eajbZce dd¡ZeedkrùddlfmgZh ddlfmi  mj  mkZl nddlmmnZh ddl	mmZl ddlmmoZompZpmqZq G dd„ deheƒZrG dd„ dƒZsetdk�r.ddluZueu v¡  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                   @   sÂ  e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dd„ Zdmdd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd „ Zd!d"„ Zd#d$„ Zd%d&„ Zd'd(„ Zd)d*„ Zd+d,„ Zd-d.„ Zed/d0„ ƒZed1d2„ ƒZdnd4d5„Zdnd6d7„Zdnd8d9„Zdnd:d;„Z dod>d?„Z!dpdAdB„Z"dCdD„ Z#dEdF„ Z$dGdH„ Z%dIZ&dJZ'dqdLdM„Z(dNdO„ Z)dPdQ„ Z*dRdS„ Z+dTdU„ Z,dVdW„ Z-dXdY„ Z.dZd[„ Z/d\d]„ Z0d^d_„ Z1d`da„ Z2dbdc„ Z3ddde„ Z4dfdg„ Z5dhdi„ Z6	 djgd3fdkdl„Z7d<S )rÚ	MPContextzH
    Context for multiprecision arithmetic with a global precision.
    c                 C   sú   t  | ¡ d| _d| _| j| j| jg| _tj	| _
|  ¡  t | ¡ tj	| _	|  ¡  i | _|  ¡  ztj| jj_tj| jj_tj| jj_tj| jj_W n! tyk   tj| jj_tj| jj_tj| jj_tj| jj_Y n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\   Ú	bernoulliZim_funcÚfunc_docÚprimepiÚpsiÚatan2ÚAttributeErrorÚ__func__ÚdigammaÚcospiÚsinpi©Úctx© r�   ú`/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/mpmath/ctx_mp.pyrh   ?   s2   

û

zMPContext.__init__c                 C   s¢  | j }| j}|  t¡| _|  t¡| _|  ttf¡| _|  t	¡| _
|  t¡| _|  t¡| _|  dd„ dd¡}|| _|  tdd¡| _|  tdd¡| _|  tdd	¡| _|  td
d¡| _|  tdd¡| _|  tdd¡| _|  tdd¡| _|  tdd¡| _ |  t!dd¡| _"|  t#dd¡| _$|  t%dd¡| _&|  t'dd¡| _(|  t)dd¡| _*|  +t,j-t,j.¡| _/|  +t,j0t,j1¡| _2|  +t,j3t,j4¡| _5|  +t,j6t,j7¡| _8|  +t,j9t,j:¡| _;|  +t,j<t,j=¡| _>|  +t,j?t,j@¡| _A|  +t,jBt,jC¡| _D|  +t,jEt,jF¡| _G|  +t,jHt,jI¡| _J|  +t,jKt,jL¡| _M|  +t,jNt,jO¡| _P|  +t,jQt,jR¡| _S|  +t,jTt,jU¡| _V|  +t,jWt,jX¡| _Y|  +t,j6t,j7¡| _8|  +t,jZt,j[¡| _\|  +t,j]t,j^¡| __|  +t,j`t,ja¡| _b|  +t,jct,jd¡| _e|  +t,jft,jg¡| _h|  +t,jit,jj¡| _k|  +t,jlt,jm¡| _n|  +t,jot,jp¡| _q|  +t,jrt,js¡| _t|  +t,jut,jv¡ | _w| _x|  +t,jyt,jz¡| _{|  +t,j|t,j}¡| _~|  +t,jt,j€¡| _�|  +t,j‚t,jƒ¡ | _„| _…|  +t,j†t,j‡¡| _ˆ|  +t,j‰t,jŠ¡| _‹|  +t,jŒt,j�¡| _Ž|  +t,j�t,j�¡| _‘|  +t,j’t,j“¡| _”|  +t,j•t,j–¡| _—|  +t,j˜t,j™¡| _š|  +t,j›t,jœ¡| _�|  +t,jžt,jŸ¡| _ |  +t,j¡d ¡| _¢|  +t,j£d ¡| _¤|  +t,j¥t,j¦¡| _§|  +t,j¨t,j©¡| _ªt«| d| j/ƒ| _/t«| d| j;ƒ| _;t«| d | j5ƒ| _5t«| d!| jGƒ| _Gt«| d"| jDƒ| _Dd S )#Nc                 S   s   dt d|  dfS )Nr   r   )r
   ©ÚprecÚrndr�   r�   r‚   Ú<lambda>m   s    z)MPContext.init_builtins.<locals>.<lambda>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ÚmertensZ
_sage_sqrtZ	_sage_expZ_sage_lnZ	_sage_cosZ	_sage_sin)¬rk   rl   Úmake_mpfr   Úoner   ÚzeroÚmake_mpcÚjr    Úinfr!   Úninfr"   Únanrm   r‡   rO   rˆ   rS   r‰   rT   rŠ   rR   r‹   rQ   rŒ   rU   r�   rV   rŽ   rX   r�   rY   r�   rW   r‘   rP   r’   rZ   r“   r[   r”   Z_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€   rk   rl   r‡   r�   r�   r‚   rr   `   s’   
ÿzMPContext.init_builtinsc                 C   s
   |  |¡S ©N)r8   )r€   Úxr„   r�   r�   r‚   r8   ¶   s   
zMPContext.to_fixedc                 C   s4   |   |¡}|   |¡}|  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  Úyr�   r�   r‚   Úhypot¹   s   

 zMPContext.hypotc                 C   sr   t |  |¡ƒ}|dkr|  |¡S t|dƒst‚| j\}}tj||j||dd�\}}|d u r2|  	|¡S |  
||f¡S )Nr   r  T)ré   )ÚintÚ_rerþ   ÚhasattrÚNotImplementedErrorr  r   Ú
mpf_expintr  r•   r˜   ©r€   ÚnÚzr„   ÚroundingÚrealÚimagr�   r�   r‚   Ú_gamma_upper_intÁ   s   



zMPContext._gamma_upper_intc                 C   sh   t |ƒ}|dkr|  |¡S t|dƒst‚| j\}}t ||j||¡\}}|d u r-|  |¡S |  	||f¡S )Nr   r  )
r!  rþ   r#  r$  r  r   r%  r  r•   r˜   r&  r�   r�   r‚   Ú_expint_intÎ   s   



zMPContext._expint_intc                 C   st   t |dƒr)z|  tj|j|g| j¢R Ž ¡W S  ty(   | jr ‚ |jtjf}Y nw |j	}|  
tj||g| j¢R Ž ¡S ©Nr  )r#  r•   r   Úmpf_nthrootr  r  r   ri   r   Ú_mpc_r˜   Úmpc_nthroot©r€   r  r'  r�   r�   r‚   Ú_nthrootÛ   s   
 ýzMPContext._nthrootc                 C   sR   | j \}}t|dƒr|  t ||j||¡¡S t|dƒr'|  t ||j||¡¡S d S ©Nr  r0  )	r  r#  r•   r   Úmpf_besseljnr  r˜   Úmpc_besseljnr0  )r€   r'  r(  r„   r)  r�   r�   r‚   Ú_besseljç   s   


ÿzMPContext._besseljr   c                 C   s¤   | j \}}t|dƒr)t|dƒr)zt |j|j||¡}|  |¡W S  ty(   Y nw t|dƒr5|jtjf}n|j}t|dƒrD|jtjf}n|j}|  	t 
||||¡¡S r.  )r  r#  r   Úmpf_agmr  r•   r   r   r0  r˜   Úmpc_agm)r€   ÚaÚbr„   r)  Úvr�   r�   r‚   Ú_agmî   s   
ÿzMPContext._agmc                 C   ó   |   tjt|ƒg| j¢R Ž ¡S r  )r•   r   Úmpf_bernoullir!  r  ©r€   r'  r�   r�   r‚   ru   ü   ó   zMPContext.bernoullic                 C   r>  r  )r•   r   Úmpf_zeta_intr!  r  r@  r�   r�   r‚   Ú	_zeta_intÿ   rA  zMPContext._zeta_intc                 C   s4   |   |¡}|   |¡}|  tj|j|jg| j¢R Ž ¡S r  )r  r•   r   Ú	mpf_atan2r  r  )r€   r  r  r�   r�   r‚   ry     s   

 zMPContext.atan2c                 C   sX   |   |¡}t|ƒ}|  |¡r|  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_psir0  )r€   Úmr(  r�   r�   r‚   rx     s
   

zMPContext.psic                 K   ó®   t |ƒ| jvr|  |¡}|  |¡\}}t|dƒr,t |j||¡\}}|  |¡|  |¡fS t|dƒrEt 	|j
||¡\}}|  |¡|  |¡fS | j|fi |¤Ž| j|fi |¤ŽfS r4  )Útypern   r  Ú_parse_precr#  r   Úmpf_cos_sinr  r•   Úmpc_cos_sinr0  r˜   r·   r´   ©r€   r  Úkwargsr„   r)  ÚcÚsr�   r�   r‚   Úcos_sin  ó   


$zMPContext.cos_sinc                 K   rI  r4  )rJ  rn   r  rK  r#  r   Úmpf_cos_sin_pir  r•   Úmpc_cos_sin_pir0  r˜   r·   r´   rN  r�   r�   r‚   Úcospi_sinpi  rS  zMPContext.cospi_sinpic                 C   s   |   ¡ }| j|_|S )zP
        Create a copy of the context, with the same working precision.
        )Ú	__class__r„   )r€   r:  r�   r�   r‚   Úclone)  s   zMPContext.clonec                 C   ó   t |dƒst|ƒtu rdS dS )Nr0  FT©r#  rJ  Úcomplex©r€   r  r�   r�   r‚   rE  4  ó   zMPContext._is_real_typec                 C   rY  )Nr0  TFrZ  r\  r�   r�   r‚   Ú_is_complex_type9  r]  zMPContext._is_complex_typec                 C   sr   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ƒs0t |dƒr5|  	|¡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  r0  Fzisnan() needs a number as input)r#  r  r"   r0  Ú
isinstancer   r]   ro   r  ÚisnanÚ	TypeErrorr\  r�   r�   r‚   r`  >  s   





zMPContext.isnanc                 C   s   |   |¡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)Úisinfr`  r\  r�   r�   r‚   ÚisfiniteZ  s   zMPContext.isfinitec                 C   sœ   |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ƒrF|j	\}}|s>dS |dkoE|dkS |  |  
|¡¡S )z<
        Determine if *x* is a nonpositive integer.
        Tr  r   r0  r   )r#  r  r+  Úisnpintr*  rJ  r   r_  ro   Ú_mpq_r  )r€   r  ÚsignÚmanr«   ÚbcÚpÚqr�   r�   r‚   rd  t  s   


zMPContext.isnpintc                 C   sF   dd| j   d¡d d| j  d¡d d| j  d¡d 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Údpsri   Újoin)r€   Úlinesr�   r�   r‚   Ú__str__ˆ  s   ý
zMPContext.__str__c                 C   s
   t | jƒS r  )r   Ú_precr   r�   r�   r‚   Ú_repr_digits�  s   
zMPContext._repr_digitsc                 C   s   | j S r  )Z_dpsr   r�   r�   r‚   Ú_str_digits”  s   zMPContext._str_digitsFc                    ó   t | ‡ fd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                    ó   | ˆ  S r  r�   ©ri  ©r'  r�   r‚   r†   ¨  ó    z%MPContext.extraprec.<locals>.<lambda>N©ÚPrecisionManager©r€   r'  Únormalize_outputr�   rx  r‚   Ú	extraprec˜  s   zMPContext.extraprecc                    ó   t | d‡ fdd„|ƒS )z–
        This function is analogous to extraprec (see documentation)
        but changes the decimal precision instead of the number of bits.
        Nc                    rv  r  r�   ©Údrx  r�   r‚   r†   ¯  ry  z$MPContext.extradps.<locals>.<lambda>rz  r|  r�   rx  r‚   Úextradpsª  ó   zMPContext.extradpsc                    ru  )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�   rw  rx  r�   r‚   r†   À  ó    z$MPContext.workprec.<locals>.<lambda>Nrz  r|  r�   rx  r‚   Úworkprec±  s   zMPContext.workprecc                    r  )z•
        This function is analogous to workprec (see documentation)
        but changes the decimal precision instead of the number of bits.
        Nc                    r„  r  r�   r€  rx  r�   r‚   r†   Ç  r…  z#MPContext.workdps.<locals>.<lambda>rz  r|  r�   rx  r‚   ÚworkdpsÂ  rƒ  zMPContext.workdpsNr�   c                    s   ‡ ‡‡‡‡fd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                     s2  ˆj }ˆd u rˆ |¡}nˆ}z…|d ˆ_ z	ˆ| i |¤Ž}W n ˆ y*   ˆj}Y nw |d }	 |ˆ_ z	ˆ| i |¤Ž}W n ˆ yH   ˆj}Y nw ||krNn9ˆ || ¡ˆ |¡ }|| k r`n.ˆrltd||| f ƒ |}||kryˆ d| ¡‚|t|d ƒ7 }t||ƒ}q0W |ˆ_ |
 S W |ˆ_ |
 S |ˆ_ w )Né
   é   r   z)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergenceé   )r„   Ú_default_hyper_maxprecrœ   ÚmagÚprintÚNoConvergencer!  Úmin)ÚargsrO  r„   Zmaxprec2Úv1Úprec2Úv2Úerr©Úcatchr€   ÚfÚmaxprecÚverboser�   r‚   Úf_autoprec_wrapped  sZ   

ÿ
ÿ

ÿÿÿ
ìóÿz.MPContext.autoprec.<locals>.f_autoprec_wrappedr�   )r€   r—  r˜  r–  r™  rš  r�   r•  r‚   ÚautoprecÉ  s   D%zMPContext.autoprecé   c                    sÐ   t |tƒrdd ‡ ‡‡fdd„|D ƒ¡ S t |tƒr*dd ‡ ‡‡fdd„|D ƒ¡ S t|dƒr9t|jˆfi ˆ¤ŽS t|dƒrLd	t|jˆfi ˆ¤Ž d
 S t |t	ƒrUt
|ƒS t |ˆ jƒrd|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   ó$   � | ]}ˆ j |ˆfi ˆ¤ŽV  qd S r  ©Únstr©Ú.0rP  ©r€   rO  r'  r�   r‚   Ú	<genexpr>]  ó   €" z!MPContext.nstr.<locals>.<genexpr>z(%s)c                 3   r�  r  rž  r   r¢  r�   r‚   r£  _  r¤  r  r0  ú(ú))r_  Úlistro  Útupler#  r   r  r9   r0  r   ÚreprÚmatrixÚ__nstr__Ústr)r€   r  r'  rO  r�   r¢  r‚   rŸ  4  s   
( 
 


zMPContext.nstrc                 C   s¬   |r7t |tƒr7d| ¡ v r7| ¡  dd¡}t |¡}| d¡}|s#d}| d¡ d¡}|  |  	|¡|  	|¡¡S t
|dƒrN|j\}}||krJ|  |¡S tdƒ‚td	t|ƒ ƒ‚)
Nr™   ú Ú Úrer   ÚimÚ_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )r_  r   ÚlowerÚreplaceÚget_complexÚmatchÚgroupÚrstriprl   r  r#  r±  r•   Ú
ValueErrorra  r©  )r€   r  Ústringsrµ  r¯  r°  r:  r;  r�   r�   r‚   Ú_convert_fallbackj  s   




zMPContext._convert_fallbackc                 O   s   | j |i |¤ŽS r  )r  )r€   r�  rO  r�   r�   r‚   Ú	mpmathify|  s   zMPContext.mpmathifyc                 C   sŽ   |rD|  d¡r	dS | j\}}d|v r|d }d|v r-|d }|| jkr%dS t|ƒ}||fS d|v r@|d }|| jkr<dS t|ƒ}||fS | jS )NÚexact)r   r—  r)  r„   rn  )Úgetr  rš   r!  r   )r€   rO  r„   r)  rn  r�   r�   r‚   rK    s&   


û
zMPContext._parse_precz'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           !      K   s¼  t |dƒr|||df}|j}	nt |dƒr|||df}|j}	|| jvr,t |¡d | j|< | j| }
| j}| d|  |¡¡}d}d}i }d	}t	|ƒD ]s\}}|| d
kr�||kr€|d	kr€d}t	|d |… ƒD ]\}}|| d
kry|d	kry||kryd}qe|s€t
dƒ‚qI|  |¡\}}t|ƒ }| }||kr¶|d	kr¶|dkr¶||v r©||  |7  < n|||< t||| d ƒ}|t|ƒ7 }qI	 ||krÍt| j||| f ƒ‚|| }|rÝtdd„ |D ƒƒ}ni }|
||	||||fi |¤Ž\}}}| }d}||k �r| ¡ D ]}|d u �s	||k �rd} nqý||d d k �p| }|�r;|�r!n'| d¡} | d u�r;|| k�r;|�r8|  d	¡S | jS |d9 }|d7 }|d7 }q¾t|ƒtu �r\|�rW|  |¡S |  |¡S |S )Nr  ÚRr0  ÚCr   r˜  é2   é   r   ÚZFTzpole in hypergeometric seriesé   é<   c                 s   s   � | ]}|d fV  qd S r  r�   )r¡  r'  r�   r�   r‚   r£  Ç  s   € z#MPContext.hypsum.<locals>.<genexpr>é   ÚzeroprecrŠ  )r#  r  r0  rs   r   Úmake_hyp_summatorr„   r½  r‹  Ú	enumerateÚZeroDivisionErrorÚnint_distancer!  ÚmaxÚabsr¸  Ú_hypsum_msgÚdictÚvaluesrl   r—   rJ  r¨  r˜   r•   )!r€   ri  rj  ÚflagsÚcoeffsr(  Zaccurate_smallrO  Úkeyr<  Zsummatorr„   r˜  r~  ZepsshiftZmagnitude_checkZmax_total_jumpÚirP  ÚokÚiiÚccr'  r�  ÚwpZmag_dictÚzvÚhave_complexZ	magnitudeÚcancelZjumps_resolvedZaccuraterÆ  r�   r�   r‚   Úhypsumš  s”   



€

ÿÿ
þ



Ý%

zMPContext.hypsumc                 C   s   |   |¡}|  t |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  r2  r�   r�   r‚   Úldexpï  s   
zMPContext.ldexpc                 C   s(   |   |¡}t |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  r'  r�   r�   r‚   Úfrexp   s   
zMPContext.frexpc                 K   s\   |   |¡\}}|  |¡}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  r0  ú2Arguments need to be mpf or mpc compatible numbers)
rK  r  r#  r•   r%   r  r˜   r>   r0  r¸  )r€   r  rO  r„   r)  r�   r�   r‚   Úfneg  s   .


zMPContext.fnegc              	   K   óø   |   |¡\}}|  |¡}|  |¡}z\t|dƒr;t|dƒr)|  t|j|j||ƒ¡W S t|dƒr;|  t|j|j||ƒ¡W S t|dƒrdt|dƒrR|  t|j|j||ƒ¡W S t|dƒri|  t	|j|j||ƒ¡W S W t
dƒ‚W t
dƒ‚ t
tfy{   t| jƒ‚w )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  r0  rà  )rK  r  r#  r•   r&   r  r˜   rB   r0  rA   r¸  ÚOverflowErrorÚ_exact_overflow_msg©r€   r  r  rO  r„   r)  r�   r�   r‚   ÚfaddF  s*   8







üüþ
ÿzMPContext.faddc              	   K   sü   |   |¡\}}|  |¡}|  |¡}z^t|dƒr=t|dƒr)|  t|j|j||ƒ¡W S t|dƒr=|  t|jtf|j	||ƒ¡W S t|dƒrft|dƒrT|  t
|j	|j||ƒ¡W S t|dƒrk|  t|j	|j	||ƒ¡W S W tdƒ‚W tdƒ‚ ttfy}   t| jƒ‚w )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  r0  rà  )rK  r  r#  r•   r'   r  r˜   rC   r   r0  rD   r¸  rã  rä  rå  r�   r�   r‚   Úfsub�  s*   0







üüþ
ÿzMPContext.fsubc              	   K   râ  )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  r0  rà  )rK  r  r#  r•   r(   r  r˜   rF   r0  rE   r¸  rã  rä  rå  r�   r�   r‚   ÚfmulÒ  s*   3







üüþ
ÿzMPContext.fmulc                 K   sÖ   |   |¡\}}|stdƒ‚|  |¡}|  |¡}t|dƒr@t|dƒr-|  t|j|j||ƒ¡S t|dƒr@|  t|jt	f|j
||ƒ¡S t|dƒrgt|dƒrV|  t|j
|j||ƒ¡S t|dƒrg|  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  r0  rà  )rK  r¸  r  r#  r•   r*   r  r˜   rH   r   r0  rI   rå  r�   r�   r‚   Úfdiv  s    1







zMPContext.fdivc                 C   sø  t |ƒ}|tv rt|ƒ| jfS |tju rD|j\}}t||ƒ\}}d| |kr+|d7 }n|s2|| jfS tt	|||  ƒƒt|ƒ }||fS t
|dƒrP|j}| j}	n;t
|dƒrs|j\}}
|
\}}}}|rg|| }	n$|
tkro| j}	ntdƒ‚|  |¡}t
|dƒs‚t
|dƒr‡|  |¡S tdƒ‚|\}}}}|| }|dk ržd}|}nW|rç|dkr¬||> }| j}n5|dkr¹|d? d }d}n(| d }||? }|d@ rÑ|d7 }||> | }n|||> 8 }|d? }|t|ƒ }|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  r0  zrequires a finite numberzrequires an mpf/mpcr   éÿÿÿÿ)rJ  r   r!  r›   r]   ro   re  Údivmodr7   rÌ  r#  r  r0  r   r¸  r  rÊ  ra  rË  )r€   r  Ztypxri  rj  r'  Úrr�  r¯  Zim_distr°  ÚisignÚimanÚiexpÚibcrf  rg  r«   rh  rŒ  Zre_distÚtr�   r�   r‚   rÊ  Y  sn   !










€zMPContext.nint_distancec                 C   s6   | j }z| j}|D ]}||9 }q	W || _ |
 S || _ w )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Úorigr<  ri  r�   r�   r‚   Úfprod»  s   
ÿÿzMPContext.fprodc                 C   s   |   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•   r5   rr  r   r�   r�   r‚   ÚrandÐ  s   zMPContext.randc                    s   |   ‡ ‡fdd„dˆ ˆf ¡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                    s   t ˆ ˆ| |ƒS r  )r   rƒ   ©ri  rj  r�   r‚   r†   ê  s    z$MPContext.fraction.<locals>.<lambda>z%s/%s)rm   )r€   ri  rj  r�   rö  r‚   ÚfractionØ  s   
ÿzMPContext.fractionc                 C   ó   t |  |¡ƒS r  ©rÌ  r  r\  r�   r�   r‚   Úabsminí  ó   zMPContext.absminc                 C   rø  r  rù  r\  r�   r�   r‚   Úabsmaxð  rû  zMPContext.absmaxc                 C   s,   t |dƒr|j\}}|  |¡|  |¡gS |S )Nr±  )r#  r±  r•   )r€   r  r:  r;  r�   r�   r‚   Ú
_as_pointsó  s   

zMPContext._as_pointsr   c           	         sl   ˆ   |¡r
t|dƒst‚t|ƒ}ˆ j}t |j|||||¡\}}‡ fdd„|D ƒ}‡ fdd„|D ƒ}||fS )Nr0  c                    ó   g | ]}ˆ   |¡‘qS r�   ©r˜   )r¡  r  r   r�   r‚   Ú
<listcomp>  ó    z+MPContext._zetasum_fast.<locals>.<listcomp>c                    rþ  r�   rÿ  )r¡  r  r   r�   r‚   r     r  )Úisintr#  r$  r!  rr  r   Úmpc_zetasumr0  )	r€   rQ  r:  r'  ÚderivativesÚreflectr„   ÚxsÚysr�   r   r‚   Ú_zetasum_fast  s   zMPContext._zetasum_fast)r   ©F)Nr�   F)rœ  )T)8Ú__name__Ú
__module__Ú__qualname__Ú__doc__rh   rr   r8   r   r,  r-  r3  r7  r=  ru   rC  ry   rx   rR  rV  rX  rE  r^  r`  rc  rd  rq  Úpropertyrs  rt  r~  r‚  r†  r‡  r›  rŸ  rº  r»  rK  rä  rÍ  rÛ  rÝ  rß  rá  ræ  rç  rè  ré  rÊ  rô  rõ  r÷  rú  rü  rý  r  r�   r�   r�   r‚   re   :   sp    !V








k6
U6JBEBbre   c                   @   s.   e Zd Zddd„Zdd„ Zdd„ Zdd	„ Zd
S )r{  Fc                 C   s   || _ || _|| _|| _d S r  )r€   ÚprecfunÚdpsfunr}  )Úselfr€   r  r  r}  r�   r�   r‚   rh     s   
zPrecisionManager.__init__c                    s   t  ˆ ¡‡ ‡fdd„ƒ}|S )Nc                     s¤   ˆj j}zHˆjrˆ ˆj j¡ˆj _n	ˆ ˆj j¡ˆj _ˆjrAˆ | i |¤Ž}t|ƒtu r9tdd„ |D ƒƒW |ˆj _S |
 W |ˆj _S ˆ | i |¤ŽW |ˆj _S |ˆj _w )Nc                 S   s   g | ]}|
 ‘qS r�   r�   )r¡  r:  r�   r�   r‚   r   '  s    z8PrecisionManager.__call__.<locals>.g.<locals>.<listcomp>)r€   r„   r  r  rn  r}  rJ  r¨  )r�  rO  ró  r<  ©r—  r  r�   r‚   Úg  s   
ü
þz$PrecisionManager.__call__.<locals>.g)Ú	functoolsÚwraps)r  r—  r  r�   r  r‚   Ú__call__  s   zPrecisionManager.__call__c                 C   s<   | j j| _| jr|  | j j¡| j _d S |  | j j¡| j _d S r  )r€   r„   Úorigpr  r  rn  )r  r�   r�   r‚   Ú	__enter__.  s   
zPrecisionManager.__enter__c                 C   s   | j | j_dS rf   )r  r€   r„   )r  Úexc_typeÚexc_valÚexc_tbr�   r�   r‚   Ú__exit__4  s   
zPrecisionManager.__exit__Nr	  )r
  r  r  rh   r  r  r  r�   r�   r�   r‚   r{    s
    
r{  Ú__main__)wr  Ú__docformat__r  r¯  Úctx_baser   Z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.   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]   ÚobjectÚ__new__ÚnewÚcompiler´  Zsage.libs.mpmath.ext_mainr_   rg   ZlibsÚmpmathZext_mainÚ_mpf_modulera   r`   rb   rc   rd   re   r{  r
  ÚdoctestÚtestmodr�   r�   r�   r‚   Ú<module>   sD    þ^ 
         d
$þ