+ j,RtRt^RIt^RIt^RIHt^RIHtHt^RI H t ^RI H t H t H t HtHtHtHtHtHtHtHtHtHtHtHtHtHtHtHtHtHtH t H!t!H"t"H#t#H$t$H%t%H&t&H't'H(t(H)t)H*t*H+t+H,t,H-t-H.t.H/t/H0t0H1t1H2t2H3t3H4t4H5t5H6t6H7t7H8t8H9t9H:t:H;t;Ht>H?t?H@t@HAtAHBtBHCtCHDtDHEtEHFtFHGtGHHtHHItIHJtJHKtKHLtLHMtMHNtNHOtOHPtPHQtQHRtRHStSHTtTHUtUHVtVHWtWHXtXHYtYHZtZH[t[H\t\H]t]H^t^Ht^RI H_t_^RI H`t`]aPtc]P!R 4te]R 8Xd^R IfHgth^RIfHiuHjuHktlM ^R ImHnth^R I Hmtl^RImHotoHptpHqtq!RR]h]4tr!RR4ts]tR8Xd^RIutu]uP!4R#R#)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 mpnumericca]tRt^:toRtRtRtRtRtRt Rt Rt R t R8R lt R tR tR tRtRtRtRtRtRtRtRtRtRt]R4t]R4tR9RltR9RltR9Rlt R9Rlt!R:R lt"R;R!lt#R"t$R#t%R$t&R%t'R&t(R-:-D-DCMM ! ! *+8+@+@CKK   ('4'8'8CGGOO $)6)<).;.E.ECMM " " +,9,A,ACKK )(5(9(9CGG   %*7*=*=CII   '  >sB$GB/I;:I;cVPpVPpVP\4VnVP\ 4VnVP\ \34VnVP\4Vn VP\4Vn VP\4VnVPRRR4pW0nVP\"RR4VnVP\&RR4VnVP\*RR4VnVP\.RR 4VnVP\2R R 4VnVP\6R R 4VnVP\:RR4VnVP\>RR4Vn VP\BRR4Vn"VP\FRR4Vn$VP\JRR4Vn&VP\NRR4Vn(VP\RRR4Vn*VPW\XPZ\XP\4Vn/VPW\XP`\XPb4Vn2VPW\XPf\XPh4Vn5VPW\XPl\XPn4Vn8VPW\XPr\XPt4Vn;VPW\XPx\XPz4Vn>VPW\XP~\XP4VnAVPW\XP\XP4VnDVPW\XP\XP4VnGVPW\XP\XP4VnJVPW\XP\XP4VnMVPW\XP\XP4VnPVPW\XP\XP4VnSVPW\XP\XP4VnVVPW\XP\XP4VnYVPW\XPl\XPn4Vn8VPW\XP\XP4Vn\VPW\XP\XP4Vn_VPW\XP\XP4VnbVPW\XP\XP4VneVPW\XP\XP4VnhVPW\XP\XP4VnkVPW\XP\XP4VnnVPW\XP\XP4VnqVPW\XP\XP4VntVPW\XP\XP4;VnwVnxVPW\XP\XP4Vn{VPW\XP\XP4Vn~VPW\XP\XEP4VnVPW\XEP\XEP4;VnVnVPW\XEP \XEP4VnVPW\XEP\XEP4VnVPW\XEP\XEP4VnVPW\XEP\XEP 4VnVPW\XEP$\XEP&4VnVPW\XEP*\XEP,4VnVPW\XEP0\XEP24VnVPW\XEP6\XEP84VnVPW\XEP<\XEP>4VnVPW\XEPBR4VnVPW\XEPFR4VnVPW\XEPJ\XEPL4VnVPW\XEPP\XEPR4VnE\WVRVP^4Vn/E\WVRVPv4Vn;E\WVRVPj4Vn5E\WVR VP4VnGE\WVR!VP4VnDR#)"c$^\^V, ^3#))r )precrnds&&r)MPContext.init_builtins..msa!D&!-Dzepsilon 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' constantmertensN _sage_sqrt _sage_exp_sage_ln _sage_cos _sage_sin)rkrlmake_mpfronerzeromake_mpcjrinfr ninfr!nanrmrrNrrRrrSrrQrrPrrTrrUrrWrrXrrVrrOrrYrrZr_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)rrkrlrs& rrrMPContext.init_builtins`sgggg,,t$<<& eD\*,,t$<<&,,t$llD *E3fdD1,,w7<<(F;,,w(:EB UL#6LL,>H ll;0DiP ||L2GT ||L2GT LL,>H \\*.@(K  ]4I;W ll;0CYO ++ENNENNK++ENNENNK))%--G++ENNENNK**5==%--H++ENNENNK--e.>.>@P@PQ **5==%--H**5==%--H**5==%--H++ENNENNK++ENNENNK++ENNENNK++ENNENNK++ENNENNK++ENNENNK,,U__eooN ,,U__eooN ,,U__eooN ,,U-=-=u?O?OP ,,U-=-=u?O?OP ,,U__eooN ++ENNENNK++ENNENNK++ENNENNK"%":":5;N;NPUPcPc"dd#-,,U__eooN --e.>.>@P@PQ //0B0BEDVDVW "%":":5;N;NPUPcPc"dd#-..u~~u~~N //0B0BEDVDVW ))%,, E))%,, E**5<<F**5<<F--e.>.>@P@PQ ..u/?/?AQAQR ++ENNENNK++EMM4@,,U^^TB ,,U^^U^^L //0A0A5CTCTU 3 chh7#{CGG4j#&&1#{CGG4#{CGG4rc$VPV4#N)r7)rxrs&&&rr7MPContext.to_fixedszz$rc VPV4pVPV4pVP\P!VPVP.VP O5!4#)zp 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'ys&&&rhypotMPContext.hypotsK KKN KKN||EOOAGGQWWRs?Q?QRSSrcJ\VPV44pV^8XdVPV4#\VR4'g\hVP wr4\ P!WPW4RR7wrVVfVPV4#VPWV34#)rr,T)r) int_rer hasattrNotImplementedErrorr-r mpf_expintr,rrrnzrroundingrealimags&&& r_gamma_upper_intMPContext._gamma_upper_ints  O 666!9 q'""% %++%%a$M  <<<% %<< - -rc(\V4pV^8XdVPV4#\VR4'g\hVPwr4\ P !WPW44wrVVfVPV4#VPWV34#)r,) r2r r4r5r-rr6r,rrr7s&&& r _expint_intMPContext._expint_ints} F 666!9 q'""% %++%%a$A  <<<% %<< - -rc\VR4'd>VP\P!VPV.VP O5!4#VPpVP\P!W.VP O5!4# \ d3TP'dhTP\P3pLmi;ir,) r4rr mpf_nthrootr,r-rrir_mpc_r mpc_nthrootrr'r8s&&&r_nthrootMPContext._nthroots 1g   +||E$5$5aggq$V3CUCU$VWW A||E--aHS5G5GHII ! +###WWekk* +s;B C *C  C c*VPwr4\VR4'd1VP\P!WP W444#\VR4'd1VP \P!WPW444#R#)r,rFN) r-r4rr mpf_besseljnr,r mpc_besseljnrF)rr8r9rr:s&&& r_besseljMPContext._besseljsn++ 1g  << 2 21ggt NO O Q << 2 21ggt NO O!rc<VPwr4\VR4'dQ\VR4'd?\P!VPVPW44pVP V4#\VR4'dVP\P3pM VPp\VR4'dVP\P3pM VPpVP\P!WW444# \ dLi;irD) r-r4rmpf_agmr,rrrrFrmpc_agm)rabrr:vs&&& r_agmMPContext._agms++ 1g  71g#6#6 MM!''177DC||A& 1g  QWWekk$:''a 1g  QWWekk$:''a||EMM!?@@ !  s>> from mpmath import * >>> isnan(3.14) False >>> isnan(nan) True >>> isnan(mpc(3.14,2.72)) False >>> isnan(mpc(3.14,nan)) True r,rFFzisnan() needs a number as input) r4r,r!rF isinstancer r\ror*isnan TypeErrorrs&&rrMPContext.isnan>s" 1g  77d? " 1g  177? " a # #z!X\\'B'B KKN 1g  '!W"5"599Q< 9::rc fVPV4'gVPV4'dR#R#)aX 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)isinfrrs&&risfiniteMPContext.isfiniteZs#, 99Q<<399Q<<rc V'gR#\VR4'dVPwr#rET;'dV^8#\VR4'd5VP'*;'dVPVP4#\ V4\ 9dV^8*#\WP4'd+VPwrgV'gR#V^8H;'dV^8*#VPVPV44#)z, Determine if *x* is a nonpositive integer. Tr,rF) r4r,r<isnpintr;rkr rro_mpq_r*)rr'signmanrbcpqs&& rrMPContext.isnpintts 1g  !" Ds$$C1H $ 1g  vv:55#++aff"5 5 7i 6M a ! !77DA6$$a1f ${{3;;q>**rcRRVP,P^4R,RVP,P^4R,RVP,P^4R,.pRP V4#)zMpmath settings:z mp.prec = %sz [default: 53]z mp.dps = %sz [default: 15]z mp.trap_complex = %sz[default: False] )rljustdpsrijoin)rliness& r__str__MPContext.__str__st#  ( / / 3o E sww & - -b 1O C %(8(8 8 ? ? CFX X  yyrc,\VP4#r&)r _precrs&r _repr_digitsMPContext._repr_digitss ""rcVP#r&)_dpsrs&r _str_digitsMPContext._str_digitss xxrFc (a\VV3RlRV4#)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<VS,#r&rr8s&rr%MPContext.extraprec..s q1urNPrecisionManagerrr8normalize_outputs&f&r extraprecMPContext.extraprecs  _d.s QUrrrs&f&rextradpsMPContext.extradpss  T? 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. c<S#r&rrs&rr$MPContext.workprec..sqrNrrs&f&rworkprecMPContext.workprecs [$8HIIrc (a\VRV3RlV4#)z} This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. Nc<S#r&rrs&rr#MPContext.workdps..sQrrrs&f&rworkdpsMPContext.workdpss  T;8HIIrNc $aaaaaVVVVV3RlpV#)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 PpS fS PV4pMS pV^ ,S nS !V/VBpV^,pVS nS !V/VBpWF8XdMS PWd, 4S PV4, pWr)8dMfS 'd\ RV: RV: RV): 24TpWS8dS P RV,4hV\ V^,4, p\WS4pKVS nV5# SdS PpLi;i SdS PpLi;i TS ni;i)Nzautoprec: target=z, prec=z , accuracy=z2autoprec: prec increased to %i without convergence)r_default_hyper_maxprecrmagprint NoConvergencer2min) argsrprmaxprec2v1prec2v2errcatchrfmaxprecverboses *, rf_autoprec_wrapped.MPContext.autoprec..f_autoprec_wrapped sN88D55d;" "9!D+F+Br $CH%//x''"%.3772;6Ce}#USD23B(!//L !!Sq\)E0E3J5!B!!% WW%$ sYD6DD6DAD6AD6DD6DD6D30D62D33D66 D?r)rrrrrrsfffff rautoprecMPContext.autoprecsH$ $ J"!rc faaa\V\4'd%RRPVVV3RlV44,#\V\4'd%RRPVVV3RlV44,#\ VR4'd\ VP S3/SB#\ VR4'd&R\VPS3/SB,R ,#\V\4'd \V4#\VSP4'dVP!S3/SB#\V4#) a; 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, c3L<"TFpSP!VS3/SBxK R#5ir&nstr.0rqrrpr8s& r !MPContext.nstr..]!&KAsxx1'?'?!$z(%s)c3L<"TFpSP!VS3/SBxK R#5ir&rrs& rrr_rrr,rF())rlistrtupler4rr,r8rFrreprmatrix__nstr__str)rr'r8rpsf&flrrMPContext.nstr4sP a  TYY&K&KKL L a  TYY&K&KKL L 1g  !''1// / 1g  AGGQ9&99S@ @ a $ $7N a $ $::a*6* *1v rcbV'd\V\4'dRVP49dVP4PRR4p\P V4pVP R4pV'g^pVP R4PR4pVPVPV4VPV44#\VR4'd1VPwrgWg8XdVPV4#\R4h\R\V4,4h)r reim_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rrlowerreplace get_complexmatchgrouprstriprlr*r4rr ValueErrorrr)rr'stringsrrrrSrTs&&& r_convert_fallbackMPContext._convert_fallbackjs z!Z00aggiGGI%%c2.#))!,[[&B[[&--c2wws{{2 B@@ 1g  77DAv||A& !OPP1DG;< ! &Um''>!M"3'> !!!!rz'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.c t\VR4'dWVR3pVPp M#\VR4'dWVR3pVPp XVP9d+\P !V4^,VPV&VPV,p VP p VPRVPV 44p ^2p ^p/p^p\V4FwppVV,R8XdbVV8dYV^8:dRRp\VRV4F*wppVV,R8XgKV^8:gKVV8:gK(RpK, V'g \R 4hKuVPV4wpp\V4)pV)pVV8dKV^8dDV^8d=VV9dVV;;,V, uu&MVVV&\V VV , ^<,4p V\V4, pK W8d%\VP WV ,3,4hW,pV'd\#R V44pM/pV !VX V VVV3/VBwpppV)pRpV V8d'VP%4FpVe VV 8gKRpM VV ^, ^, 8;'gV'*pV'dKV'dM_VPR 4p V e-VV 8d&V'dVP'^4#VP(#V ^,p V^, pV ^, p EK&\+V4\,Jd+V'dVP/V4#VP1V4#V#) r,RrFCrZFNTzpole in hypergeometric seriesc3("TFqR3xK R#5ir&r)rr8s& rr#MPContext.hypsum..sB/Q4/szeroprec)r4r,rFrsrmake_hyp_summatorrrr enumerateZeroDivisionError nint_distancer2maxabsr _hypsum_msgdictvaluesrlrrkrrr)!rrrflagscoeffsr9accurate_smallrpkeyrUsummatorrrrepsshiftmagnitude_checkmax_total_jumpirqokiiccr8rwpmag_dictzv have_complex magnitudecanceljumps_resolvedaccurater s!&&&&&&&, rhypsumMPContext.hypsums 1g  s"CA Q s"CA c'' '%*%<%)!*A q4x).+2a/EE~3EH!::j1'('#&771:-#&88O NI MH NI 8u ||B''||B''Irc VPV4pVP\P!VPV44#)aF 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,rHs&&&rldexpMPContext.ldexps/ KKN||EOOAGGQ788rc VPV4p\P!VP4wr#VP V4V3#)z 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.r8s&& rfrexpMPContext.frexps8 KKNqww'||A!!rc <VPV4wr4VPV4p\VR4'd&VP\ VP W444#\VR4'd&VP \VPW444#\R4h)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,rF2Arguments need to be mpf or mpc compatible numbers) rlr*r4rr$r,rr=rFr)rr'rprr:s&&, rfnegMPContext.fnegs|\0 KKN 1g  << @A A 1g  << @A AMNNrc 0VPV4wrEVPV4pVPV4p\VR4'd\VR4'd1VP\ VP VP WE44#\VR4'd1VP \VPVP WE44#\VR4'd\VR4'd1VP \VPVP WE44#\VR4'd1VP \VPVPWE44#\R4h \\3d\TP4hi;i)a3 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,rFr3) rlr*r4rr%r,rrArFr@r OverflowError_exact_overflow_msgrr'r.rprr:s&&&, rfaddMPContext.faddFs7p0 KKN KKN 9q'""1g&&<<$(QRR1g&&<< AGGQWWd(UVVq'""1g&&<< AGGQWWd(UVV1g&&<<$(QRRMNNM* 9 7 78 8 9!AE. AE. AE.!AE..'Fc <VPV4wrEVPV4pVPV4p\VR4'd\VR4'd1VP\ VP VP WE44#\VR4'd7VP \VP \3VPWE44#\VR4'd\VR4'd1VP \VPVP WE44#\VR4'd1VP \VPVPWE44#\R4h \\3d\TP4hi;i)aY 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,rFr3)rlr*r4rr&r,rrBrrFrCrr7r8r9s&&&, rfsubMPContext.fsubs<`0 KKN KKN 9q'""1g&&<<$(QRR1g&&<<%0@!''4(Z[[q'""1g&&<< AGGQWWd(UVV1g&&<<$(QRRMNNM* 9 7 78 8 9s!AE4 AE4AE4'AE44'Fc 0VPV4wrEVPV4pVPV4p\VR4'd\VR4'd1VP\ VP VP WE44#\VR4'd1VP \VPVP WE44#\VR4'd\VR4'd1VP \VPVP WE44#\VR4'd1VP \VPVPWE44#\R4h \\3d\TP4hi;i)ae 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,rFr3) rlr*r4rr'r,rrErFrDrr7r8r9s&&&, rfmulMPContext.fmuls7f0 KKN KKN 9q'""1g&&<<$(QRR1g&&<< AGGQWWd(UVVq'""1g&&<< AGGQWWd(UVV1g&&<<$(QRRMNNM* 9 7 78 8 9r<c VPV4wrEV'g \R4hVPV4pVPV4p\VR4'd\VR4'd1VP \ VP VP WE44#\VR4'd7VP\VP \3VPWE44#\VR4'd\VR4'd1VP\VPVP WE44#\VR4'd1VP\VPVPWE44#\R4h)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,rFr3) rlrr*r4rr)r,rrGrrFrHr9s&&&, rfdivMPContext.fdivsb0AB B KKN KKN 1g  q'""||GAGGQWWd$MNNq'""||GQWWe,>> 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,rFzrequires a finite numberzrequires an mpf/mpc)rkr r2rr\rordivmodr6rr4r,rFrrr*rrr)rr'typxrrr8rrrim_distrisignimaniexpibcrrrrrre_distts&& rrMPContext.nint_distanceYs.BAw 9 q6388# # X\\ !77DA!>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> fprod([1, 2, 0.5, 7]) mpf('7.0') )rr)rfactorsorigrUrs&& rfprodMPContext.fprodsCxx AHr Hs4<c JVP\VP44#)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. )rr4rrs&rrandMPContext.rands ||HSYY/00rc BaaVPVV3RlS: RS: 24#)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<\SSW4#r&)r)rrrrs&&rr$MPContext.fraction..smAq$.Lr/)rm)rrrs&ffrfractionMPContext.fractions!$||L!  rc6\VPV44#r&rr*rs&&rabsminMPContext.absmin3;;q>""rc6\VPV44#r&rbrs&&rabsmaxMPContext.absmaxrerc\VR4'd1VPwr#VPV4VPV4.#V#)r)r4rr)rr'rSrTs&& r _as_pointsMPContext._as_pointss: 1g  77DALLOS\\!_5 5rcnVPV4'd\VR4'g\h\V4pVPp\ P !VPW#WEV4wrxVU u.uFqPV 4NK pp VU u.uFqPV 4NK pp Wx3#uup iuup i)rF) isintr4r5r2rr mpc_zetasumrFr) rrrrSr8 derivativesreflectrxsysr'r.s &&&&&& r _zetasum_fastMPContext._zetasum_fast s ! G!4!4% % Fyy""177A+M') *r!ll1or *') *r!ll1or *v + *s 0B-B2r)r@F)NrF))T);__name__ __module__ __qualname____firstlineno____doc__rhrrr7r/r=rArIrNrVrur^rzryrsrxr|rdrrrrrpropertyrrrrrrrrrrrlr8rr(r,r0r4r:r>rArDrrVrYr_rcrgrjrs__static_attributes____classdictcell__ __classdict__s@rrere:sd1BT5l T . . JP ANMT P > >  ;84+( ##N$NJ"Ji"V4l=$,"*DKSj9"" 4OlHOT@ODCOJ@OD`(D*1*##"23Urrec<a]tRtRtoRRltRtRtRtRtVt R#) ric6WnW nW0nW@nR#r&)rprecfundpsfunr)selfrrrrs&&&&&rrhPrecisionManager.__init__s  0rcJaa\P!S4VV3Rl4pV#)cj<SPPpSP'd6SPSPP4SPnM4SPSPP4SPnSP 'd\S!V/VBp\ V4\Jd-\VUu.uFqD5NK up4VSPn#V5VSPn#S!V/VBVSPn#uupi TSPni;ir&)rrrrrrrkr)rrprUrUrSrrs*, rg$PrecisionManager.__call__..gs88==D %<<<$(LL$?DHHM#';;txx||#r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\object__new__newcompilersage.libs.mpmath.ext_mainr^rglibsmpmathext_main _mpf_moduler`r_rarbrcrerrwdoctesttestmodrrrrs   ).. nnjjKL  fB33?.00Y 2Yv&!!H z OOr