U
    :qLe,Á  ã                   @   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rZddluZueu v¡  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dod6d7„Zdpd8d9„Zdqd:d;„Z drd>d?„Z!dsdAdB„Z"dCdD„ Z#dEdF„ Z$dGdH„ Z%dIZ&dJZ'dtdLdM„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„ Z6djgd3fdkdl„Z7d<S )uÚ	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 | _|  ¡  z4tj| jj_tj| jj_tj| jj_tj| jj_W nD tk
rØ   tj| jj_tj| jj_tj| jj_tj| jj_Y nX 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_funcZfunc_docÚprimepiÚpsiÚatan2ÚAttributeErrorÚ__func__ÚdigammaÚcospiÚsinpi©Úctx© r€   úd/home/p21-0144/sympy/latex2sympy2solve-back-end/sympyEq/lib/python3.8/site-packages/mpmath/ctx_mp.pyrh   ?   s0    



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,jt,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   ó    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   s2   |   |¡}|   |¡}|  tj|j|jf| jžŽ ¡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   sv   t |  |¡ƒ}|dkr |  |¡S t|dƒs.t‚| j\}}tj||j||dd\}}|d krd|  	|¡S |  
||f¡S d 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   sl   t |ƒ}|dkr|  |¡S t|dƒs(t‚| j\}}t ||j||¡\}}|d krZ|  |¡S |  	||f¡S d 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ƒrTz|  tj|j|f| jžŽ ¡W S  tk
rP   | jr@‚ |jtjf}Y qZX n|j	}|  
tj||f| jžŽ ¡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ƒrN|  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ƒrTt|dƒrTz t |j|j||¡}|  |¡W S  tk
rR   Y nX t|dƒrl|jtjf}n|j}t|dƒrŠ|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   s   |   tjt|ƒf| jžŽ ¡S r  )r•   r   Úmpf_bernoullir!  r  ©r   r'  r€   r€   r   ru   ü   s    zMPContext.bernoullic                 C   s   |   tjt|ƒf| jžŽ ¡S r  )r•   r   Úmpf_zeta_intr!  r  r?  r€   r€   r   Ú	_zeta_intÿ   s    zMPContext._zeta_intc                 C   s2   |   |¡}|   |¡}|  tj|j|jf| jžŽ ¡S r  )r  r•   r   Ú	mpf_atan2r  r  )r   r  r  r€   r€   r   rx     s    

zMPContext.atan2c                 C   sX   |   |¡}t|ƒ}|  |¡r8|  tj||jf| jžŽ ¡S |  tj	||j
f| jžŽ ¡S d S r  )r  r!  Ú_is_real_typer•   r   Úmpf_psir  r  r˜   Úmpc_psir0  )r   Úmr(  r€   r€   r   rw     s
    

zMPContext.psic                 K   sª   t |ƒ| jkr|  |¡}|  |¡\}}t|dƒrXt |j||¡\}}|  |¡|  |¡fS t|dƒrŠt 	|j
||¡\}}|  |¡|  |¡fS | j|f|Ž| j|f|ŽfS d 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  s    


zMPContext.cos_sinc                 K   sª   t |ƒ| jkr|  |¡}|  |¡\}}t|dƒrXt |j||¡\}}|  |¡|  |¡fS t|dƒrŠt 	|j
||¡\}}|  |¡|  |¡fS | j|f|Ž| j|f|ŽfS d S r4  )rG  rn   r  rH  r#  r   Úmpf_cos_sin_pir  r•   Úmpc_cos_sin_pir0  r˜   r·   r´   rK  r€   r€   r   Úcospi_sinpi  s    


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   s   t |dƒst|ƒtkrdS dS )Nr0  FT©r#  rG  Úcomplex©r   r  r€   r€   r   rC  4  s    zMPContext._is_real_typec                 C   s   t |dƒst|ƒtkrdS dS )Nr0  TFrU  rW  r€   r€   r   Ú_is_complex_type9  s    zMPContext._is_complex_typec                 C   sv   t |dƒr|jtkS t |dƒr(t|jkS t|tƒs>t|tjƒrBdS |  |¡}t |dƒs`t |dƒrj|  	|¡S t
dƒ‚dS )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 inputN)r#  r  r"   r0  Ú
isinstancer   r]   ro   r  ÚisnanÚ	TypeErrorrW  r€   r€   r   rZ  >  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)ÚisinfrZ  rW  r€   r€   r   ÚisfiniteZ  s    zMPContext.isfinitec                 C   sœ   |sdS t |dƒr,|j\}}}}|o*|dkS t |dƒrJ|j oH|  |j¡S t|ƒtk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   r0  r   )r#  r  r+  Úisnpintr*  rG  r   rY  ro   Ú_mpq_r  )r   r  ÚsignÚmanr«   ÚbcÚpÚqr€   r€   r   r^  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                    s   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   | ˆ  S r  r€   ©rc  ©r'  r€   r   r…   ¨  r†   z%MPContext.extraprec.<locals>.<lambda>N©ÚPrecisionManager©r   r'  Únormalize_outputr€   rp  r   Ú	extraprec˜  s    zMPContext.extraprecc                    s   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                    s   | ˆ  S r  r€   ©Údrp  r€   r   r…   ¯  r†   z$MPContext.extradps.<locals>.<lambda>rq  rs  r€   rp  r   Úextradpsª  s    zMPContext.extradpsc                    s   t | ‡ fd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   ˆ S r  r€   ro  rp  r€   r   r…   À  r†   z$MPContext.workprec.<locals>.<lambda>Nrq  rs  r€   rp  r   Úworkprec±  s    zMPContext.workprecc                    s   t | d‡ fdd„|ƒS )z•
        This function is analogous to workprec (see documentation)
        but changes the decimal precision instead of the number of bits.
        Nc                    s   ˆ S r  r€   rv  rp  r€   r   r…   Ç  r†   z#MPContext.workdps.<locals>.<lambda>rq  rs  r€   rp  r   ÚworkdpsÂ  s    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                     s  ˆj }ˆd krˆ |¡}nˆ}zð|d ˆ_ zˆ| |Ž}W n ˆ k
rR   ˆj}Y nX |d }|ˆ_ zˆ| |Ž}W n ˆ k
rŠ   ˆj}Y nX ||kr˜qˆ || ¡ˆ |¡ }|| k r¾qˆrÖtd||| f ƒ |}||krðˆ d| ¡‚|t|d ƒ7 }t||ƒ}q\W 5 |ˆ_ X |
 S )Né
   é   z)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergenceé   )rƒ   Ú_default_hyper_maxprecrœ   ÚmagÚprintÚNoConvergencer!  Úmin)ÚargsrL  rƒ   Zmaxprec2Úv1Úprec2Úv2Úerr©Úcatchr   ÚfÚmaxprecÚverboser€   r   Úf_autoprec_wrapped  sH    


ÿÿÿ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ƒrTdd ‡ ‡‡fdd„|D ƒ¡ S t|dƒrnt|jˆfˆŽS t|dƒrd	t|jˆfˆŽ d
 S t |t	ƒr¢t
|ƒS t |ˆ jƒr¼|jˆfˆŽ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   s   | ]}ˆ j |ˆfˆŽV  qd S r  ©Únstr©Ú.0rM  ©r   rL  r'  r€   r   Ú	<genexpr>]  s     z!MPContext.nstr.<locals>.<genexpr>z(%s)c                 3   s   | ]}ˆ j |ˆfˆŽV  qd S r  r  r’  r”  r€   r   r•  _  s     r  r0  ú(ú))rY  Úlistri  Útupler#  r   r  r9   r0  r   ÚreprÚmatrixÚ__nstr__Ústr)r   r  r'  rL  r€   r”  r   r‘  4  s    (
 
 


zMPContext.nstrc                 C   s°   |rnt |tƒrnd| ¡ krn| ¡  dd¡}t |¡}| d¡}|sFd}| d¡ d¡}|  |  	|¡|  	|¡¡S t
|dƒrœ|j\}}||kr”|  |¡S tdƒ‚td	t|ƒ ƒ‚d S )
Nr™   ú Ú Úrer   ÚimÚ_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rY  r   ÚlowerÚreplaceÚget_complexÚmatchÚgroupÚrstriprl   r  r#  r¢  r•   Ú
ValueErrorr[  rš  )r   r  Zstringsr¦  r   r¡  r:  r;  r€   r€   r   Ú_convert_fallbackj  s    




zMPContext._convert_fallbackc                 O   s   | j ||ŽS r  )r  )r   rƒ  rL  r€   r€   r   Ú	mpmathify|  s    zMPContext.mpmathifyc                 C   sˆ   |r‚|  d¡rdS | j\}}d|kr,|d }d|krT|d }|| jkrJdS t|ƒ}n&d|krz|d }|| jkrrdS t|ƒ}||fS | jS )NÚexact)r   rŠ  r)  rƒ   rh  )Úgetr  rš   r!  r   )r   rL  rƒ   r)  rh  r€   r€   r   rH    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krXt |¡d | j|< | j| }
| j}| d|  |¡¡}d}d}i }d	}t	|ƒD ]ð\}}|| d
kr||kr’|d	kr’d}t	|d |… ƒD ](\}}|| d
krÌ|d	krÌ||krÌd}qÌ|s’t
dƒ‚q’|  |¡\}}t|ƒ }| }||krv|d	krv|dkrv||kr\||  |7  < n|||< t||| d ƒ}|t|ƒ7 }q’||kr¤t| j||| f ƒ‚|| }|rÆtdd„ |D ƒƒ}ni }|
||	||||f|Ž\}}}| }d}||k r(| ¡ D ]$}|d ks||k rd} q(q||d d k p>| }|r„|rPq | d¡} | d k	r„|| kr„|r~|  d	¡S | jS |d9 }|d7 }|d7 }q„t|ƒtkrÊ|r¾|  |¡S |  |¡S n|S d 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—   rG  r™  r˜   r•   )!r   rc  rd  ÚflagsÚcoeffsr(  Zaccurate_smallrL  Úkeyr<  Zsummatorrƒ   r‹  ru  ZepsshiftZmagnitude_checkZmax_total_jumpÚirM  ÚokÚiiÚccr'  rw  Ú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ƒr6|  t|j||ƒ¡S t|dƒrT|  t|j||ƒ¡S t	dƒ‚dS )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 numbersN)
rH  r  r#  r•   r%   r  r˜   r>   r0  r©  )r   r  rL  rƒ   r)  r€   r€   r   Úfneg  s    .


zMPContext.fnegc              	   K   sú   |   |¡\}}|  |¡}|  |¡}z¨t|dƒrvt|dƒrR|  t|j|j||ƒ¡W S t|dƒrv|  t|j|j||ƒ¡W S t|dƒrÈt|dƒr¤|  t|j|j||ƒ¡W S t|dƒrÈ|  t	|j|j||ƒ¡W S W n" t
tfk
rì   t| jƒ‚Y nX t
dƒ‚dS )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Ð  N)rH  r  r#  r•   r&   r  r˜   rB   r0  rA   r©  ÚOverflowErrorÚ_exact_overflow_msg©r   r  r  rL  rƒ   r)  r€   r€   r   ÚfaddF  s"    8







zMPContext.faddc              	   K   sþ   |   |¡\}}|  |¡}|  |¡}z¬t|dƒrzt|dƒrR|  t|j|j||ƒ¡W S t|dƒrz|  t|jtf|j	||ƒ¡W S t|dƒrÌt|dƒr¨|  t
|j	|j||ƒ¡W S t|dƒrÌ|  t|j	|j	||ƒ¡W S W n" ttfk
rð   t| jƒ‚Y nX tdƒ‚dS )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Ð  N)rH  r  r#  r•   r'   r  r˜   rC   r   r0  rD   r©  rÒ  rÓ  rÔ  r€   r€   r   Úfsub  s"    0







zMPContext.fsubc              	   K   sú   |   |¡\}}|  |¡}|  |¡}z¨t|dƒrvt|dƒrR|  t|j|j||ƒ¡W S t|dƒrv|  t|j|j||ƒ¡W S t|dƒrÈt|dƒr¤|  t|j|j||ƒ¡W S t|dƒrÈ|  t	|j|j||ƒ¡W S W n" t
tfk
rì   t| jƒ‚Y nX t
dƒ‚dS )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Ð  N)rH  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ƒrZ|  t|j|j||ƒ¡S t|dƒr€|  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ƒ‚dS )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Ð  N)rH  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krt|ƒ| jfS |tjkrˆ|j\}}t||ƒ\}}d| |krV|d7 }n|sd|| jfS tt	|||  ƒƒt|ƒ }||fS t
|dƒr |j}| j}	n|t
|dƒrè|j\}}
|
\}}}}|rÎ|| }	n|
tkrÞ| j}	ntdƒ‚n4|  |¡}t
|dƒs
t
|dƒr|  |¡S tdƒ‚|\}}}}|| }|dk rDd}|}nº|rà|dkrd||> }| j}nn|dkr€|d? d }d}nR| 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   éÿÿÿÿ)rG  r   r!  r›   r]   ro   r_  Údivmodr7   r¼  r#  r  r0  r   r©  r  rº  r[  r»  )r   r  Ztypxrc  rd  r'  Úrrw  r   Zim_distr¡  ÚisignÚimanÚiexpÚibcr`  ra  r«   rb  r  Zre_distÚtr€   r€   r   rº  Y  sl    !
















zMPContext.nint_distancec                 C   s2   | j }z| j}|D ]}||9 }qW 5 || _ X |
 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Úorigr<  rc  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   rl  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‚   ©rc  rd  r€   r   r…   ê  r†   z$MPContext.fraction.<locals>.<lambda>z%s/%s)rm   )r   rc  rd  r€   rå  r   ÚfractionØ  s    
ÿzMPContext.fractionc                 C   s   t |  |¡ƒS r  ©r¼  r  rW  r€   r€   r   Úabsminí  s    zMPContext.absminc                 C   s   t |  |¡ƒS r  rç  rW  r€   r€   r   Úabsmaxð  s    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                    s   g | ]}ˆ   |¡‘qS r€   ©r˜   )r“  r  r~   r€   r   Ú
<listcomp>  s     z+MPContext._zetasum_fast.<locals>.<listcomp>c                    s   g | ]}ˆ   |¡‘qS r€   rë  )r“  r  r~   r€   r   rì    s     )Úisintr#  r$  r!  rl  r   Úmpc_zetasumr0  )	r   rN  r:  r'  ÚderivativesÚreflectrƒ   ÚxsÚysr€   r~   r   Ú_zetasum_fast  s    zMPContext._zetasum_fast)r   )F)F)F)F)Nr€   F)r  )T)8Ú__name__Ú
__module__Ú__qualname__Ú__doc__rh   rr   r8   r   r,  r-  r3  r7  r=  ru   rA  rx   rw   rO  rR  rT  rC  rX  rZ  r]  r^  rk  Úpropertyrm  rn  ru  rx  ry  rz  rŽ  r‘  rª  r«  rH  rÓ  r½  rË  rÍ  rÏ  rÑ  rÕ  rÖ  r×  rØ  rº  rã  rä  ræ  rè  ré  rê  ró  r€   r€   r€   r   re   :   sl   !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 )rr  Fc                 C   s   || _ || _|| _|| _d S r  )r   ÚprecfunÚdpsfunrt  )Úselfr   rù  rú  rt  r€   r€   r   rh     s    zPrecisionManager.__init__c                    s   t  ˆ ¡‡ ‡fdd„ƒ}|S )Nc                     s’   ˆj j}zzˆjr$ˆ ˆj j¡ˆj _nˆ ˆj j¡ˆj _ˆjrrˆ | |Ž}t|ƒtkrhtdd„ |D ƒƒW ¢S |
 W ¢S ˆ | |ŽW ¢S W 5 |ˆj _X d S )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ú  rh  rt  rG  r™  )rƒ  rL  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 _n|  | j j¡| j _d S r  )r   rƒ   Úorigprù  rú  rh  )rû  r€   r€   r   Ú	__enter__.  s    
zPrecisionManager.__enter__c                 C   s   | j | j_dS rf   )r  r   rƒ   )rû  Úexc_typeZexc_valZexc_tbr€   r€   r   Ú__exit__4  s    
zPrecisionManager.__exit__N)F)rô  rõ  rö  rh   r   r  r  r€   r€   r€   r   rr    s   
rr  Ú__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   rr  rô  ÚdoctestZtestmodr€   r€   r€   r   Ú<module>   s@   ÿ ]

         d$
