o Ɂi,@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. 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/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 precrndrrrmsz)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' constantmertens _sage_sqrt _sage_exp_sage_ln _sage_cos _sage_sin)rkrlmake_mpfronerzeromake_mpcjr infr!ninfr"nanrmrrOrrSrrTrrRrrQrrUrrVrrXrrYrrWrrPrrZrr[r_wrap_libmp_functionrmpf_sqrtmpc_sqrtsqrtmpf_cbrtmpc_cbrtcbrtmpf_logmpc_loglnmpf_atanmpc_atanatanmpf_expmpc_expexpmpf_expjmpc_expjexpj mpf_expjpi mpc_expjpiexpjpimpf_sinmpc_sinsinmpf_cosmpc_coscosmpf_tanmpc_tantanmpf_sinhmpc_sinhsinhmpf_coshmpc_coshcoshmpf_tanhmpc_tanhtanhmpf_asinmpc_asinasinmpf_acosmpc_acosacos mpf_asinh mpc_asinhasinh mpf_acosh mpc_acoshacosh mpf_atanh mpc_atanhatanh mpf_sin_pi mpc_sin_pir mpf_cos_pi mpc_cos_pir~ mpf_floor mpc_floorfloormpf_ceilmpc_ceilceilmpf_nintmpc_nintnintmpf_fracmpc_fracfrac mpf_fibonacci mpc_fibonaccifib fibonacci mpf_gamma mpc_gammagamma mpf_rgamma mpc_rgammargamma mpf_loggamma mpc_loggammaloggamma mpf_factorial mpc_factorialfac factorialmpf_psi0mpc_psi0r} mpf_harmonic mpc_harmonicharmonicmpf_eimpc_eieimpf_e1mpc_e1e1mpf_cimpc_ci_cimpf_simpc_si_si mpf_ellipk mpc_ellipkellipk mpf_ellipe mpc_ellipe_ellipempf_agm1mpc_agm1agm1mpf_erf_erfmpf_erfc_erfcmpf_zetampc_zeta_zeta mpf_altzeta mpc_altzeta_altzetagetattr)rrkrlrrrrrr`s      zMPContext.init_builtinscCs ||SN)r8)rxrrrrr8s 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.)convertrr mpf_hypot_mpf__prec_rounding)rr!yrrrhypots   zMPContext.hypotcCsrt||}|dkr||St|dst|j\}}tj||j||dd\}}|dur2| |S| ||fS)Nrr$T)r) int_rerhasattrNotImplementedErrorr%r mpf_expintr$rrrnzrroundingrealimagrrr_gamma_upper_ints    zMPContext._gamma_upper_intcCsht|}|dkr ||St|dst|j\}}t||j||\}}|dur-||S| ||fS)Nrr$) r(rr*r+r%rr,r$rrr-rrr _expint_ints    zMPContext._expint_intcCstt|dr)z|tj|j|g|jRWSty(|jr |jtjf}Ynw|j }| tj ||g|jRSNr$) r*rr mpf_nthrootr$r%rrir_mpc_r mpc_nthrootrr!r.rrr_nthroots   zMPContext._nthrootcCsR|j\}}t|dr|t||j||St|dr'|t||j||SdSNr$r7) r%r*rr mpf_besseljnr$r mpc_besseljnr7)rr.r/rr0rrr_besseljs   zMPContext._besseljrcCs|j\}}t|dr)t|dr)zt|j|j||}||WSty(Ynwt|dr5|jtjf}n|j}t|drD|jtjf}n|j}| t ||||Sr5) r%r*rmpf_agmr$rrrr7rmpc_agm)rabrr0vrrr_agms   zMPContext._agmcC|tjt|g|jRSr )rr mpf_bernoullir(r%rr.rrrruzMPContext.bernoullicCrEr )rr mpf_zeta_intr(r%rGrrr _zeta_intrHzMPContext._zeta_intcCs4||}||}|tj|j|jg|jRSr )r"rr mpf_atan2r$r%)rr&r!rrrrzs   zMPContext.atan2cCsX||}t|}||r|tj||jg|jRS|tj ||j g|jRSr ) r"r( _is_real_typerrmpf_psir$r%rmpc_psir7)rmr/rrrrys  z MPContext.psicKt||jvr ||}||\}}t|dr,t|j||\}}||||fSt|drEt |j ||\}}| || |fS|j |fi||j |fi|fSr;)typernr" _parse_precr*r mpf_cos_sinr$r mpc_cos_sinr7rrrrr!kwargsrr0csrrrcos_sin   $zMPContext.cos_sincKrPr;)rQrnr"rRr*rmpf_cos_sin_pir$rmpc_cos_sin_pir7rrrrUrrr cospi_sinpirZzMPContext.cospi_sinpicCs|}|j|_|S)zP Create a copy of the context, with the same working precision. ) __class__r)rrArrrclone)szMPContext.clonecCt|ds t|tur dSdS)Nr7FTr*rQcomplexrr!rrrrL4zMPContext._is_real_typecCr`)Nr7TFrarcrrr_is_complex_type9rdzMPContext._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 r$r7Fzisnan() needs a number as input) r*r$r"r7 isinstancer r]ror"isnan TypeErrorrcrrrrg>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)isinfrgrcrrrisfiniteZszMPContext.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. Tr$rr7r) r*r$r2isnpintr1rQr rfro_mpq_r")rr!signmanrbcpqrrrrkts      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] )rljustdpsrijoin)rlinesrrr__str__s  zMPContext.__str__cCs t|jSr )r _precrrrr _repr_digitss zMPContext._repr_digitscCs|jSr )_dpsrrrr _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|Sr rrpr.rrrz%MPContext.extraprec..NPrecisionManagerrr.normalize_outputrrr extraprecszMPContext.extraprecct|dfdd|S)z This function is analogous to extraprec (see documentation) but changes the decimal precision instead of the number of bits. Ncr~r rdrrrrrz$MPContext.extradps..rrrrrextradpszMPContext.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. cSr rrrrrrz$MPContext.workprec..NrrrrrworkprecszMPContext.workpreccr)z This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. Ncrr rrrrrrrz#MPContext.workdps..rrrrrworkdpsrzMPContext.workdpsNrcsfdd}|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_maxprecrmagprint NoConvergencer(min)argsrVrmaxprec2v1prec2v2errcatchrfmaxprecverboserrf_autoprec_wrapped sZ          z.MPContext.autoprec..f_autoprec_wrappedr)rrrrrrrrrautoprecsD%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|fiVqdSr nstr.0rWrrVr.rr ]"z!MPContext.nstr..z(%s)c3rr rrrrrr_rr$r7())rflistrvtupler*rr$r9r7rreprmatrix__nstr__str)rr!r.rVrrrr4s (       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 )rfrlowerreplace get_complexmatchgrouprstriprlr"r*rr ValueErrorrhr)rr!stringsrrrrArBrrr_convert_fallbackjs      zMPContext._convert_fallbackcOs|j|i|Sr )r")rrrVrrr mpmathify|szMPContext.mpmathifycCs|rD|dr dS|j\}}d|vr|d}d|vr-|d}||jkr%dSt|}||fSd|vr@|d}||jkr.zeroprecr)r*r$r7rsrmake_hyp_summatorrrr enumerateZeroDivisionError nint_distancer(maxabsr _hypsum_msgdictvaluesrlrrQrrr)!rrprqflagscoeffsr/accurate_smallrVkeyrCsummatorrrrepsshiftmagnitude_checkmax_total_jumpirWokiiccr.rwpmag_dictzv have_complex magnitudecanceljumps_resolvedaccuraterrrrhypsums                %  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') )r"rr mpf_shiftr$r9rrrldexps 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) )r"r mpf_frexpr$r)rr!r&r.rrrfrexps 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 r$r72Arguments need to be mpf or mpc compatible numbers) rRr"r*rr%r$rr>r7r)rr!rVrr0rrrfnegs.   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 r$r7r) rRr"r*rr&r$rrBr7rAr OverflowError_exact_overflow_msgrr!r&rVrr0rrrfaddFs*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 r$r7r)rRr"r*rr'r$rrCrr7rDrrrrrrrfsubs*0         zMPContext.fsubc Kr)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$r7r) rRr"r*rr(r$rrFr7rErrrrrrrfmuls*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 operationr$r7r) rRrr"r*rr*r$rrHrr7rIrrrrfdivs 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 rrr$r7zrequires a finite numberzrequires an mpf/mpcr)rQr r(rr]rorldivmodr7rr*r$r7rrr"rrhr)rr!typxrprqr.rrrim_distrisignimaniexpibcrmrnrrorre_disttrrrrYsn!                 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') )rr)rfactorsorigrCrprrrfprods  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. )rr5ryrrrrrandszMPContext.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 )rrrprqrrrsz$MPContext.fraction..z%s/%s)rm)rrprqrr rfractions zMPContext.fractioncCt||Sr rr"rcrrrabsminzMPContext.absmincCr r rrcrrrabsmaxrzMPContext.absmaxcCs,t|dr|j\}}||||gS|S)Nr)r*rr)rr!rArBrrr _as_pointss  zMPContext._as_pointsrc sl|r t|ds tt|}j}t|j|||||\}}fdd|D}fdd|D}||fS)Nr7cg|]}|qSrr)rr!rrr z+MPContext._zetasum_fast..crrr)rr&rrrrr)isintr*r+r(ryr mpc_zetasumr7) rrXrAr. derivativesreflectrxsysrrr _zetasum_fast szMPContext._zetasum_fast)rF)NrF)r)T)8__name__ __module__ __qualname____doc__rhrrr8r'r3r4r:r>rDrurJrzryrYr]r_rLrergrjrkrxpropertyrzr|rrrrrrrrrRrrrrrrrrrrrr r r rrrrrrrrre:sp!V              k6 U6JBEBbrec@s.eZdZd ddZddZddZdd Zd S) rFcCs||_||_||_||_dSr )rprecfundpsfunr)selfrr$r%rrrrrhs 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|]}| qSrr)rrArrrr'sz8PrecisionManager.__call__..g..)rrr$r%rurrQr)rrVrrCrr&rrgs   z$PrecisionManager.__call__..g) functoolswraps)r&rr(rr'r__call__szPrecisionManager.__call__cCs<|jj|_|jr||jj|j_dS||jj|j_dSr )rrorigpr$r%ru)r&rrr __enter__.s zPrecisionManager.__enter__cCs|j|j_dSrf)r,rr)r&exc_typeexc_valexc_tbrrr__exit__4s zPrecisionManager.__exit__Nr)rr r!rhr+r-r1rrrrrs   r__main__)wr" __docformat__r)rctx_baser libmp.backendrrrrrr 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\r]object__new__newcompilersage.libs.mpmath.ext_mainr_rglibsmpmathext_main _mpf_modulerar`rbrcrdrerrdoctesttestmodrrrrsD  ^      d $