U 9%e,@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 lfmgZhddlfmimjmkZlnddlmmnZhddl mmZlddlmmoZompZpmqZqGdddeheZrGdddZsetdkrZddluZueuvdS)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)?\)?$sage)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/d0Zed1d2Zdnd4d5Zdod6d7Zdpd8d9Zdqd:d;Z drd>d?Z!dsdAdBZ"dCdDZ#dEdFZ$dGdHZ%dIZ&dJZ'dtdLdMZ(dNdOZ)dPdQZ*dRdSZ+dTdUZ,dVdWZ-dXdYZ.dZd[Z/d\d]Z0d^d_Z1d`daZ2dbdcZ3dddeZ4dfdgZ5dhdiZ6djgd3fdkdlZ7d|+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 precZrndr|r|r}mz)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)rjrkmake_mpfronerzeromake_mpcjrinfr ninfr!nanrlrrNrrRrrSrrQrrPrrTrrUrrWrrXrrVrrOrrYrrZrZ_wrap_libmp_functionrZmpf_sqrtZmpc_sqrtsqrtZmpf_cbrtZmpc_cbrtZcbrtZmpf_logZmpc_loglnZmpf_atanZmpc_atanatanZmpf_expZmpc_expexpZmpf_expjZmpc_expjZexpjZ mpf_expjpiZ mpc_expjpiZexpjpiZmpf_sinZmpc_sinsinZmpf_cosZmpc_coscosZmpf_tanZmpc_tantanZmpf_sinhZmpc_sinhsinhZmpf_coshZmpc_coshcoshZmpf_tanhZmpc_tanhtanhZmpf_asinZmpc_asinasinZmpf_acosZmpc_acosacosZ mpf_asinhZ mpc_asinhasinhZ mpf_acoshZ mpc_acoshacoshZ mpf_atanhZ mpc_atanhatanhZ mpf_sin_piZ mpc_sin_piryZ mpf_cos_piZ mpc_cos_pirxZ mpf_floorZ mpc_floorfloorZmpf_ceilZmpc_ceilceilZmpf_nintZmpc_nintZnintZmpf_fracZmpc_fracfracZ mpf_fibonacciZ mpc_fibonacciZfibZ fibonacciZ mpf_gammaZ mpc_gammagammaZ mpf_rgammaZ mpc_rgammaZrgammaZ mpf_loggammaZ mpc_loggammaZloggammaZ mpf_factorialZ mpc_factorialZfac factorialZmpf_psi0Zmpc_psi0rwZ mpf_harmonicZ mpc_harmonicZharmonicZmpf_eiZmpc_eieiZmpf_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)r{rjrkrr|r|r}rp`s      zMPContext.init_builtinscCs ||SN)r7)r{xrr|r|r}r7szMPContext.to_fixedcCs2||}||}|tj|j|jf|jS)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)r{ryr|r|r}hypots  zMPContext.hypotcCsvt||}|dkr ||St|ds.t|j\}}tj||j||dd\}}|dkrd| |S| ||fSdS)NrrT)r) int_rerhasattrNotImplementedErrorrr mpf_expintrrrr{nzrroundingrealimagr|r|r}_gamma_upper_ints    zMPContext._gamma_upper_intcCslt|}|dkr||St|ds(t|j\}}t||j||\}}|dkrZ||S| ||fSdS)Nrr) rrrrrrrrrrrr|r|r} _expint_ints    zMPContext._expint_intcCstt|drTz|tj|j|f|jWStk rP|jr@|jtjf}YqZXn|j }| tj ||f|jSNr) rrrZ mpf_nthrootrrrrhr_mpc_rZ mpc_nthrootr{rrr|r|r}_nthroots zMPContext._nthrootcCsR|j\}}t|dr,|t||j||St|drN|t||j||SdSNrr) rrrrZ mpf_besseljnrrZ mpc_besseljnr)r{rrrrr|r|r}_besseljs    zMPContext._besseljrcCs|j\}}t|drTt|drTz t|j|j||}||WStk rRYnXt|drl|jtjf}n|j}t|dr|jtjf}n|j}| t ||||Sr) rrrZmpf_agmrrrrrrZmpc_agm)r{abrrvr|r|r}_agms    zMPContext._agmcCs|tjt|f|jSr)rrZ mpf_bernoullirrr{rr|r|r}rrszMPContext.bernoullicCs|tjt|f|jSr)rrZ mpf_zeta_intrrrr|r|r} _zeta_intszMPContext._zeta_intcCs2||}||}|tj|j|jf|jSr)rrrZ mpf_atan2rr)r{rrr|r|r}rts  zMPContext.atan2cCsX||}t|}||r8|tj||jf|jS|tj ||j f|jSdSr) rr _is_real_typerrZmpf_psirrrZmpc_psir)r{mrr|r|r}rss   z MPContext.psicKst||jkr||}||\}}t|drXt|j||\}}||||fSt|drt |j ||\}}| || |fS|j |f||j |f|fSdSr)typermr _parse_precrrZ mpf_cos_sinrrZ mpc_cos_sinrrrrr{rkwargsrrcsr|r|r}cos_sins   zMPContext.cos_sincKst||jkr||}||\}}t|drXt|j||\}}||||fSt|drt |j ||\}}| || |fS|j |f||j |f|fSdSr)rrmrrrrZmpf_cos_sin_pirrZmpc_cos_sin_pirrrrrr|r|r} cospi_sinpis   zMPContext.cospi_sinpicCs|}|j|_|S)zP Create a copy of the context, with the same working precision. ) __class__r)r{rr|r|r}clone)szMPContext.clonecCst|dst|tkrdSdS)NrFTrrcomplexr{rr|r|r}r4szMPContext._is_real_typecCst|dst|tkrdSdS)NrTFrrr|r|r}_is_complex_type9szMPContext._is_complex_typecCsvt|dr|jtkSt|dr(t|jkSt|ts>t|tjrBdS||}t|ds`t|drj| |St ddS)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 inputN) rrr!r isinstancer r\rnrisnan TypeErrorrr|r|r}r>s      zMPContext.isnancCs||s||rdSdS)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)isinfrrr|r|r}isfiniteZszMPContext.isfinitecCs|sdSt|dr,|j\}}}}|o*|dkSt|drJ|j oH||jSt|tkr^|dkSt||jr|j \}}|s|dS|dko|dkS|| |S)z< Determine if *x* is a nonpositive integer. Trrrr) rrrisnpintrrr rrn_mpq_r)r{rsignmanrbcpqr|r|r}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] )rljustdpsrhjoin)r{linesr|r|r}__str__s zMPContext.__str__cCs t|jSr)r _precrzr|r|r} _repr_digitsszMPContext._repr_digitscCs|jSr)Z_dpsrzr|r|r} _str_digitsszMPContext._str_digitsFcst|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. cs|Srr|rrr|r}rrz%MPContext.extraprec..NPrecisionManagerr{rnormalize_outputr|rr} extraprecszMPContext.extrapreccst|dfdd|S)z This function is analogous to extraprec (see documentation) but changes the decimal precision instead of the number of bits. Ncs|Srr|drr|r}rrz$MPContext.extradps..rrr|rr}extradpsszMPContext.extradpscst|fddd|S)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. csSrr|rrr|r}rrz$MPContext.workprec..Nrrr|rr}workprecszMPContext.workpreccst|dfdd|S)z This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. NcsSrr|rrr|r}rrz#MPContext.workdps..rrr|rr}workdpsszMPContext.workdpsNr|csfdd}|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 csj}dkr|}n}z|d_z||}Wnk rRj}YnX|d}|_z||}Wnk rj}YnX||krq |||}|| krq rtd||| f|}||krd||t|d7}t||}q\W5|_X| S)N z)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergence)r_default_hyper_maxprecrmagprintZ NoConvergencermin)argsrrZmaxprec2Zv1Zprec2Zv2errcatchr{fmaxprecverboser|r}f_autoprec_wrapped sH      z.MPContext.autoprec..f_autoprec_wrappedr|)r{r r r rrr|r r}autoprecsD%zMPContext.autoprecc st|tr*ddfdd|DSt|trTddfdd|DSt|drnt|jfSt|drd t|jfd St|t rt |St|j r|j fSt |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, c3s|]}j|fVqdSrnstr.0rr{rrr|r} ]sz!MPContext.nstr..z(%s)c3s|]}j|fVqdSrrrrr|r}r_srr())rlistrtuplerrrr8rrreprmatrixZ__nstr__str)r{rrrr|rr}r4s(        zMPContext.nstrcCs|rnt|trnd|krn|dd}t|}|d}|sFd}|dd}|| || |St |dr|j \}}||kr| |St dtd t|dS) Nr rerim_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rrlowerreplace get_complexmatchgrouprstriprkrrr#r ValueErrorrr)r{rstringsr'r!r"rrr|r|r}_convert_fallbackjs      zMPContext._convert_fallbackcOs |j||Sr)r)r{rrr|r|r} mpmathify|szMPContext.mpmathifycCs|r|drdS|j\}}d|kr,|d}d|krT|d}||jkrJdSt|}n&d|krz|d}||jkrrdSt|}||fS|jS)Nexact)rr rrr)getrrrr)r{rrrrr|r|r}rs$     zMPContext._parse_precz'the exact result does not fit in memoryzhypsum() 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!Kst|dr|||df}|j} nt|dr:|||df}|j} ||jkrXt|d|j|<|j|} |j} |d|| } d} d}i}d }t |D]\}}||d kr||kr|d krd }t |d|D](\}}||d kr|d kr||krd }q|st d q| |\}}t | }| }||krv|d krv|dkrv||kr\|||7<n|||<t | || d} |t|7}q| | krt|j| | | f| | }|rtdd|D}ni}| || | |||f|\}}}| }d }| |kr(|D]$}|dks|| krd }q(q|| ddkp>| }|r|rPq|d} | dk r|| kr|r~|d S|jS| d9} |d7}| d7} qt|tkr|r||S||Sn|SdS)NrRrCrr 2rZFTzpole in hypergeometric series<css|]}|dfVqdSrr|)rrr|r|r}rsz#MPContext.hypsum..zeroprecr)rrrrqrZmake_hyp_summatorrr/r enumerateZeroDivisionError nint_distancermaxabsr* _hypsum_msgdictvaluesrkrrrrr)!r{rrflagsZcoeffsrZaccurate_smallrkeyrZsummatorrr rZepsshiftZmagnitude_checkZmax_total_jumpirokiiccrrZwpZmag_dictZzvZ have_complexZ magnitudecancelZjumps_resolvedZaccurater8r|r|r}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_shiftrrr|r|r}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)r{rrrr|r|r}frexps zMPContext.frexpcKs`||\}}||}t|dr6|t|j||St|drT|t|j||St ddS)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 numbersN) rrrrr$rrr=rr*)r{rrrrr|r|r}fnegs.   zMPContext.fnegc Ks||\}}||}||}zt|drvt|drR|t|j|j||WSt|drv|t|j|j||WSt|drt|dr|t|j|j||WSt|dr|t |j|j||WSWn"t t fk rt |j YnXt ddS)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 rrrKN) rrrrr%rrrArr@r* OverflowError_exact_overflow_msgr{rrrrrr|r|r}faddFs"8        zMPContext.faddc Ks||\}}||}||}zt|drzt|drR|t|j|j||WSt|drz|t|jtf|j ||WSt|drt|dr|t |j |j||WSt|dr|t|j |j ||WSWn"t t fk rt |j YnXt ddS)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 rrrKN)rrrrr&rrrBrrrCr*rMrNrOr|r|r}fsubs"0        zMPContext.fsubc Ks||\}}||}||}zt|drvt|drR|t|j|j||WSt|drv|t|j|j||WSt|drt|dr|t|j|j||WSt|dr|t |j|j||WSWn"t t fk rt |j YnXt ddS)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 rrrKN) rrrrr'rrrErrDr*rMrNrOr|r|r}fmuls"3        zMPContext.fmulcKs||\}}|std||}||}t|drt|drZ|t|j|j||St|dr|t|jt f|j ||St|drt|dr|t |j |j||St|dr|t|j |j ||StddS)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 operationrrrKN) rr*rrrr)rrrGrrrHrOr|r|r}fdivs 1        zMPContext.fdivcCs t|}|tkrt||jfS|tjkr|j\}}t||\}}d||krV|d7}n|sd||jfStt |||t|}||fSt |dr|j }|j} n|t |dr|j \}} | \} } } }| r| |} n| t kr|j} ntdn4||}t |ds t |dr||Std|\}}}}||}|dkrDd}|}n|r|dkrd||>}|j}nn|dkr|d?d}d}nR| 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\rnrdivmodr6r=rrrrr*rr;rr<)r{rZtypxrrrrrr!Zim_distr"ZisignZimanZiexpZibcrrrrrZre_disttr|r|r}r;Ysl!                       zMPContext.nint_distancecCs2|j}z|j}|D] }||9}qW5||_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') )rr)r{Zfactorsorigrrr|r|r}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. )rr4rrzr|r|r}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~rrr|r}rrz$MPContext.fraction..z%s/%s)rl)r{rrr|r[r}fractions zMPContext.fractioncCst||Srr=rrr|r|r}absminszMPContext.absmincCst||Srr]rr|r|r}absmaxszMPContext.absmaxcCs,t|dr(|j\}}||||gS|S)Nr#)rr#r)r{rrrr|r|r} _as_pointss  zMPContext._as_pointsrc sl|rt|dstt|}j}t|j|||||\}}fdd|D}fdd|D}||fS)Nrcsg|]}|qSr|r)rrrzr|r} sz+MPContext._zetasum_fast..csg|]}|qSr|ra)rrrzr|r}rbs)ZisintrrrrrZ mpc_zetasumr) r{rrrZ derivativesZreflectrZxsZysr|rzr} _zetasum_fast szMPContext._zetasum_fast)r)F)F)F)F)Nr|F)r)T)8__name__ __module__ __qualname____doc__rgrpr7rrrrrrrrrrtrsrrrrrrrrrpropertyrrrrrrrrr,r-rrNr>rHrIrJrLrPrQrRrSr;rYrZr\r^r_r`rcr|r|r|r}rd:sl!V              k 6 U6JBEBbrdc@s.eZdZd ddZddZddZdd Zd S) rFcCs||_||_||_||_dSr)r{precfundpsfunr)selfr{rirjrr|r|r}rgszPrecisionManager.__init__cstfdd}|S)Ncsjj}zzjr$jjj_njjj_jrr||}t|tkrhtdd|DWS| WS||WSW5|j_XdS)NcSsg|] }| qSr|r|)rrr|r|r}rb'sz8PrecisionManager.__call__..g..)r{rrirjrrrr)rrrXrr rkr|r}gs   z$PrecisionManager.__call__..g) functoolswraps)rkr rmr|rlr}__call__szPrecisionManager.__call__cCs:|jj|_|jr$||jj|j_n||jj|j_dSr)r{rorigprirjr)rkr|r|r} __enter__.s zPrecisionManager.__enter__cCs|j|j_dSre)rqr{r)rkexc_typeexc_valexc_tbr|r|r}__exit__4s zPrecisionManager.__exit__N)F)rdrerfrgrprrrvr|r|r|r}rs r__main__)wrg __docformat__rnr!Zctx_baserZ libmp.backendrrr rrrr 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__newcompiler&Zsage.libs.mpmath.ext_mainr^rfZlibsZmpmathZext_mainZ _mpf_moduler`r_rarbrcrdrrddoctesttestmodr|r|r|r}s@  ]       d$