o tVa,@s`dZdZddlZddlZddlmZddlmZmZddl m Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm 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;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^mZdd l m_Z_dd l m`Z`eajbZcedd Zeed krdd lfmgZhddlfmimjmkZln ddlmmnZhddl mmZlddlmmoZompZpmqZqGdddeheZrGdddZsetdkr.ddluZueuvdSdS)z[ This module defines the mpf, mpc classes, and standard functions for operating with them. Z plaintextN)StandardBaseContext) basestringBACKEND)libmp)UMPZMPZ_ZEROMPZ_ONE int_typesrepr_dps round_floor round_ceiling dps_to_prec round_nearest prec_to_dps ComplexResult to_pickable from_pickable normalizefrom_int from_floatfrom_strto_intto_floatto_str from_rational from_man_expfonefzerofinffninffnanmpf_absmpf_posmpf_negmpf_addmpf_submpf_mul mpf_mul_intmpf_div mpf_rdiv_int mpf_pow_intmpf_modmpf_eqmpf_cmpmpf_ltmpf_gtmpf_lempf_gempf_hashmpf_randmpf_sumbitcountto_fixed mpc_to_strmpc_to_complexmpc_hashmpc_posmpc_is_nonzerompc_neg mpc_conjugatempc_absmpc_add mpc_add_mpfmpc_sub mpc_sub_mpfmpc_mul mpc_mul_mpf mpc_mul_intmpc_div mpc_div_mpfmpc_pow mpc_pow_mpf mpc_pow_int mpc_mpf_divmpf_powmpf_pi mpf_degreempf_empf_phimpf_ln2mpf_ln10 mpf_euler mpf_catalan mpf_apery mpf_khinchin mpf_glaisher mpf_twinprime mpf_mertensr ) function_docs)rationalz\^\(?(?P[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?)??(?P[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?j)?\)?$Zsage)Context)PythonMPContext) ctx_mp_python)_mpf_mpc mpnumericc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ dmddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zed/d0Zed1d2Zdnd4d5Zdnd6d7Zdnd8d9Zdnd:d;Z dod>d?Z!dpdAdBZ"dCdDZ#dEdFZ$dGdHZ%dIZ&dJZ'dqdLdMZ(dNdOZ)dPdQZ*dRdSZ+dTdUZ,dVdWZ-dXdYZ.dZd[Z/d\d]Z0d^d_Z1d`daZ2dbdcZ3dddeZ4dfdgZ5dhdiZ6 djgd3fdkdlZ7d|+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,jt,j|_|+t,jt,j|_|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jt,j|_|+t,jd|_|+t,jd|_|+t,jt,j|_|+t,jt,j|_t|d|j/|_/t|d|j;|_;t|d |j5|_5t|d!|jG|_Gt|d"|jD|_DdS)#NcSsdtd|dfS)Nrr)r precZrndrzrzr{msz)MPContext.init_builtins..zepsilon of working precisionepspizln(2)ln2zln(10)ln10zGolden ratio phiphiz e = exp(1)ezEuler's constanteulerzCatalan's constantcatalanzKhinchin's constantkhinchinzGlaisher's constantglaisherzApery's constantaperyz1 deg = pi / 180degreezTwin prime constant twinprimezMertens' constantmertensZ _sage_sqrtZ _sage_expZ_sage_lnZ _sage_cosZ _sage_sin)rhrimake_mpfronerzeromake_mpcjrinfr ninfr!nanrjrrNrrRrrSrrQrrPrrTrrUrrWrrXrrVrrOrrYrrZrZ_wrap_libmp_functionrZmpf_sqrtZmpc_sqrtZsqrtZmpf_cbrtZmpc_cbrtZcbrtZmpf_logZmpc_logZlnZmpf_atanZmpc_atanZatanZmpf_expZmpc_expexpZmpf_expjZmpc_expjZexpjZ mpf_expjpiZ mpc_expjpiZexpjpiZmpf_sinZmpc_sinsinZmpf_cosZmpc_coscosZmpf_tanZmpc_tanZtanZmpf_sinhZmpc_sinhZsinhZmpf_coshZmpc_coshZcoshZmpf_tanhZmpc_tanhZtanhZmpf_asinZmpc_asinZasinZmpf_acosZmpc_acosZacosZ mpf_asinhZ mpc_asinhZasinhZ mpf_acoshZ mpc_acoshZacoshZ mpf_atanhZ mpc_atanhZatanhZ mpf_sin_piZ mpc_sin_pirwZ mpf_cos_piZ mpc_cos_pirvZ mpf_floorZ mpc_floorZfloorZmpf_ceilZmpc_ceilZceilZmpf_nintZmpc_nintZnintZmpf_fracZmpc_fracZfracZ mpf_fibonacciZ mpc_fibonacciZfibZ fibonacciZ mpf_gammaZ mpc_gammagammaZ mpf_rgammaZ mpc_rgammaZrgammaZ mpf_loggammaZ mpc_loggammaZloggammaZ mpf_factorialZ mpc_factorialZfacZ factorialZmpf_psi0Zmpc_psi0ruZ mpf_harmonicZ mpc_harmonicZharmonicZmpf_eiZmpc_eiZeiZmpf_e1Zmpc_e1e1Zmpf_ciZmpc_ciZ_ciZmpf_siZmpc_siZ_siZ mpf_ellipkZ mpc_ellipkZellipkZ mpf_ellipeZ mpc_ellipeZ_ellipeZmpf_agm1Zmpc_agm1Zagm1Zmpf_erfZ_erfZmpf_erfcZ_erfcZmpf_zetaZmpc_zetaZ_zetaZ mpf_altzetaZ mpc_altzetaZ_altzetagetattr)ryrhrirrzrzr{rn`s      zMPContext.init_builtinscCs ||SN)r7)ryxr}rzrzr{r7s zMPContext.to_fixedcCs4||}||}|tj|j|jg|jRS)z Computes the Euclidean norm of the vector `(x, y)`, equal to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real.)convertrrZ mpf_hypot_mpf__prec_rounding)ryryrzrzr{hypots   zMPContext.hypotcCsrt||}|dkr||St|dst|j\}}tj||j||dd\}}|dur2| |S| ||fS)NrrT)r) int_rerhasattrNotImplementedErrorrr mpf_expintrrrrynzr}roundingrealimagrzrzr{_gamma_upper_ints    zMPContext._gamma_upper_intcCsht|}|dkr ||St|dst|j\}}t||j||\}}|dur-||S| ||fS)Nrr) rrrrrrrrrrrrzrzr{ _expint_ints    zMPContext._expint_intcCstt|dr)z|tj|j|g|jRWSty(|jr |jtjf}Ynw|j }| tj ||g|jRSNr) rrrZ mpf_nthrootrrrrgr_mpc_rZ mpc_nthrootryrrrzrzr{_nthroots   zMPContext._nthrootcCsR|j\}}t|dr|t||j||St|dr'|t||j||SdSNrr) rrrrZ mpf_besseljnrrZ mpc_besseljnr)ryrrr}rrzrzr{_besseljs   zMPContext._besseljrcCs|j\}}t|dr)t|dr)zt|j|j||}||WSty(Ynwt|dr5|jtjf}n|j}t|drD|jtjf}n|j}| t ||||Sr) rrrZmpf_agmrrrrrrZmpc_agm)ryabr}rvrzrzr{_agms   zMPContext._agmcC|tjt|g|jRSr)rrZ mpf_bernoullirrryrrzrzr{rpzMPContext.bernoullicCrr)rrZ mpf_zeta_intrrrrzrzr{ _zeta_intrzMPContext._zeta_intcCs4||}||}|tj|j|jg|jRSr)rrrZ mpf_atan2rr)ryrrrzrzr{rrs   zMPContext.atan2cCsX||}t|}||r|tj||jg|jRS|tj ||j g|jRSr) rr _is_real_typerrZmpf_psirrrZmpc_psir)rymrrzrzr{rqs  z MPContext.psicKt||jvr ||}||\}}t|dr,t|j||\}}||||fSt|drEt |j ||\}}| || |fS|j |fi||j |fi|fSr)typerkr _parse_precrrZ mpf_cos_sinrrZ mpc_cos_sinrrrrryrkwargsr}rcsrzrzr{cos_sin   $zMPContext.cos_sincKrr)rrkrrrrZmpf_cos_sin_pirrZmpc_cos_sin_pirrrrrrzrzr{ cospi_sinpirzMPContext.cospi_sinpicCs|}|j|_|S)zP Create a copy of the context, with the same working precision. ) __class__r})ryrrzrzr{clone)szMPContext.clonecCt|ds t|tur dSdS)NrFTrrcomplexryrrzrzr{r4zMPContext._is_real_typecCr)NrTFrrrzrzr{_is_complex_type9rzMPContext._is_complex_typecCsrt|dr |jtkSt|drt|jvSt|tst|tjr!dS||}t|ds0t|dr5| |St 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 rrFzisnan() needs a number as input) rrr!r isinstancer r\rlrisnan TypeErrorrrzrzr{r>s      zMPContext.isnancCs||s ||r dSdS)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)Zisinfrrrzrzr{isfiniteZszMPContext.isfinitecCs|sdSt|dr|j\}}}}|o|dkSt|dr%|j o$||jSt|tvr/|dkSt||jrF|j \}}|s>dS|dkoE|dkS|| |S)z< Determine if *x* is a nonpositive integer. Trrrr) rrrisnpintrrr rrl_mpq_r)ryrsignmanrbcpqrzrzr{rts      zMPContext.isnpintcCsFdd|jddd|jddd|jddg}d |S) NzMpmath settings:z mp.prec = %sz [default: 53]z mp.dps = %sz [default: 15]z mp.trap_complex = %sz[default: False] )r}ljustdpsrgjoin)rylinesrzrzr{__str__s  zMPContext.__str__cCs t|jSr)r _precrxrzrzr{ _repr_digitss zMPContext._repr_digitscCs|jSr)Z_dpsrxrzrzr{ _str_digitsszMPContext._str_digitsFct|fddd|S)a The block with extraprec(n): increases the precision n bits, executes , 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|Srrzrrrzr{r~z%MPContext.extraprec..NPrecisionManagerryrnormalize_outputrzrr{ extraprecszMPContext.extraprecct|dfdd|S)z This function is analogous to extraprec (see documentation) but changes the decimal precision instead of the number of bits. Ncrrrzdrrzr{r~rz$MPContext.extradps..rrrzrr{extradpszMPContext.extradpscr)a The block with workprec(n): sets the precision to n bits, executes , 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. cSrrzrrrzr{r~z$MPContext.workprec..Nrrrzrr{workprecszMPContext.workpreccr)z This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. Ncrrrzrrrzr{r~rz#MPContext.workdps..rrrzrr{workdpsrzMPContext.workdpsNrzcsfdd}|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 cs2j}dur |}n}z|d_z |i|}Wn y*j}Ynw|d} |_z |i|}Wn yHj}Ynw||krNn9|||}|| kr`n.rltd||| f|}||kryd||t|d7}t||}q0W|_| SW|_| S|_w)N rz)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergence)r}_default_hyper_maxprecrmagprintZ NoConvergencermin)argsrr}Zmaxprec2Zv1Zprec2Zv2errcatchryfmaxprecverboserzr{f_autoprec_wrapped sZ          z.MPContext.autoprec..f_autoprec_wrappedrz)ryrrrrrrzrr{autoprecsD%zMPContext.autoprecc st|trddfdd|DSt|tr*ddfdd|DSt|dr9t|jfiSt|drLd t|jfid St|t rUt |St|j rd|j fiSt |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, c3$|] }j|fiVqdSrnstr.0rryrrrzr{ ]"z!MPContext.nstr..z(%s)c3r rr r rrzr{r_rrr())rlistrtuplerrrr8rrreprZmatrixZ__nstr__str)ryrrrrzrr{r 4s (       zMPContext.nstrcCs|r7t|tr7d|vr7|dd}t|}|d}|s#d}|dd}|| || |St |drN|j \}}||krJ| |St dtd t|) Nr rerim_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rrlowerreplace get_complexmatchgrouprstriprirrrr ValueErrorrr)ryrstringsr rrrrrzrzr{_convert_fallbackjs      zMPContext._convert_fallbackcOs|j|i|Sr)r)ryrrrzrzr{ mpmathify|szMPContext.mpmathifycCs|rD|dr dS|j\}}d|vr|d}d|vr-|d}||jkr%dSt|}||fSd|vr@|d}||jkr.zeroprecr)rrrrorZmake_hyp_summatorr}r(r enumerateZeroDivisionError nint_distancermaxabsr# _hypsum_msgdictvaluesrirrrrr)!ryrrflagsZcoeffsrZaccurate_smallrkeyrZsummatorr}rrZepsshiftZmagnitude_checkZmax_total_jumpirokiiZccrrZwpZmag_dictZzvZ have_complexZ magnitudeZcancelZjumps_resolvedZaccurater1rzrzr{hypsums                %  zMPContext.hypsumcCs||}|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') )rrrZ mpf_shiftrrrzrzr{ldexps zMPContext.ldexpcCs(||}t|j\}}|||fS)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) )rrZ mpf_frexprr)ryrrrrzrzr{frexps zMPContext.frexpcKs\||\}}||}t|dr|t|j||St|dr*|t|j||St 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 rr2Arguments need to be mpf or mpc compatible numbers) rrrrr$rrr=rr#)ryrrr}rrzrzr{fnegs.   zMPContext.fnegc K||\}}||}||}z\t|dr;t|dr)|t|j|j||WSt|dr;|t|j|j||WSt|drdt|drR|t|j|j||WSt|dri|t |j|j||WSWt dWt dt t fy{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 rrrB) rrrrr%rrrArr@r# OverflowError_exact_overflow_msgryrrrr}rrzrzr{faddFs*8         zMPContext.faddc Ks||\}}||}||}z^t|dr=t|dr)|t|j|j||WSt|dr=|t|jtf|j ||WSt|drft|drT|t |j |j||WSt|drk|t|j |j ||WSWt dWt dt t fy}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 rrrB)rrrrr&rrrBrrrCr#rErFrGrzrzr{fsubs*0         zMPContext.fsubc KrD)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 rrrB) rrrrr'rrrErrDr#rErFrGrzrzr{fmuls*3         zMPContext.fmulcKs||\}}|s td||}||}t|dr@t|dr-|t|j|j||St|dr@|t|jt f|j ||St|drgt|drV|t |j |j||St|drg|t|j |j ||Std)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 operationrrrB) rr#rrrr)rrrGrrrHrGrzrzr{fdivs 1        zMPContext.fdivcCst|}|tvrt||jfS|tjurD|j\}}t||\}}d||kr+|d7}n|s2||jfStt |||t|}||fSt |drP|j }|j} n;t |drs|j \}} | \} } } }| rg| |} n$| t kro|j} ntd||}t |dst |dr||Std|\}}}}||}|dkrd}|}nW|r|dkr||>}|j}n5|dkr|d?d}d}n(| d}||?}|d@r|d7}||>|}n|||>8}|d?}|t|}|r| }n|t kr|j}d}ntd|t|| fS) 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 rrrrzrequires a finite numberzrequires an mpf/mpcr)rr rrr\rlrdivmodr6r6rrrrr#rr4rr5)ryrZtypxrrrrrrZim_distrZisignZimanZiexpZibcrrrrrZre_disttrzrzr{r4Ysn!                 zMPContext.nint_distancecCs6|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)ryZfactorsorigrrrzrzr{fprods  zMPContext.fprodcCs|t|jS)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. )rr4rrxrzrzr{randszMPContext.randcs|fdddfS)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 cst||Sr)rr|rrrzr{r~sz$MPContext.fraction..z%s/%s)rj)ryrrrzrSr{fractions zMPContext.fractioncCt||Srr6rrrzrzr{absminzMPContext.absmincCrUrrVrrzrzr{absmaxrXzMPContext.absmaxcCs,t|dr|j\}}||||gS|S)Nr)rrr)ryrrrrzrzr{ _as_pointss  zMPContext._as_pointsrc sl|r t|ds tt|}j}t|j|||||\}}fdd|D}fdd|D}||fS)Nrcg|]}|qSrzr)rrrxrzr{ z+MPContext._zetasum_fast..cr[rzr\)rrrxrzr{r]r^)ZisintrrrrrZ mpc_zetasumr) ryrrrZ derivativesZreflectr}ZxsZysrzrxr{ _zetasum_fast szMPContext._zetasum_fast)rF)NrzF)r )T)8__name__ __module__ __qualname____doc__rfrnr7rrrrrrrprrrrqrrrrrrrrrpropertyrrrrrrrr r%r&rrFr7r?r@rArCrHrIrJrKr4rQrRrTrWrYrZr_rzrzrzr{rc:sp!V              k6 U6JBEBbrcc@s.eZdZd ddZddZddZdd Zd S) rFcCs||_||_||_||_dSr)ryprecfundpsfunr)selfryrfrgrrzrzr{rfs zPrecisionManager.__init__cstfdd}|S)Ncsjj}zHjrjjj_n jjj_jrA|i|}t|tur9tdd|DW|j_S| W|j_S|i|W|j_S|j_w)NcSsg|]}| qSrzrz)rrrzrzr{r]'sz8PrecisionManager.__call__..g..)ryr}rfrgrrrr)rrrPrrrhrzr{gs   z$PrecisionManager.__call__..g) functoolswraps)rhrrjrzrir{__call__szPrecisionManager.__call__cCs<|jj|_|jr||jj|j_dS||jj|j_dSr)ryr}origprfrgr)rhrzrzr{ __enter__.s zPrecisionManager.__enter__cCs|j|j_dSrd)rnryr})rhexc_typeZexc_valexc_tbrzrzr{__exit__4s zPrecisionManager.__exit__Nr`)rarbrcrfrmrorrrzrzrzr{rs   r__main__)wrdZ __docformat__rkrZctx_baserZ libmp.backendrrrrrrr r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\object__new__newcompilerZsage.libs.mpmath.ext_mainr]reZlibsZmpmathZext_mainZ _mpf_moduler_r^r`rarbrcrraZdoctestZtestmodrzrzrzr{sD  ^      d $