[h,SrSrSSKrSSKrSSKJr SSKJrJr SSK J r SSK J r J r J r JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrPJQrQJRrRJSrSJTrTJUrUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^Jr SS K J_r_ SS K J`r` \aRrc\R"S 5re\S :XaSS KfJgrh SSKfJis Jjs Jkrl O SSKmJnrh SSK Jmrl SSKmJoroJprpJqrq "SS\h\5rr"SS5rs\tS:XaSSKuru\uR"5 gg)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\rSrSrSrSrSrSrSrSr Sr S r S r S:S jr S rS rSrSrSrSrSrSrSrSrSrSrSr\S5r\S5rS;SjrS;SjrS;Sjr S;Sjr!SS)jr)S*r*S+r+S,r,S-r-S.r.S/r/S0r0S1r1S2r2S3r3S4r4S5r5S6r6S7r7S8/S4S9jr8S!r9g )? MPContext:z@ Context for multiprecision arithmetic with a global precision. c[R"U5 SUlSUlURUR UR /Ul[RUl UR5 [R"U5 [RUl UR5 0UlUR5 [ R"UR"R$l[ R(UR(R$l[ R*UR*R$l[ R,UR,R$l[ R2UR2l[ R4UR4l[ R6UR6lg![.a [ R"UR"R0l[ R(UR(R0l[ R*UR*R0l[ R,UR,R0lGNf=fNF) BaseMPContext__init__ trap_complexprettympfmpcconstanttypesr^mpq_mpqdefaultr init_builtins hyp_summators _init_aliasesr] bernoulliim_funcfunc_docprimepipsiatan2AttributeError__func__digammacospisinpictxs E/var/www/auris/envauris/lib/python3.13/site-packages/mpmath/ctx_mp.pyrlMPContext.__init__?ss#  WWcggs||4 << $$S),,   >-:-D-DCMM ! ! *+8+@+@CKK   ('4'8'8CGGOO $)6)<).;.E.ECMM " " +,9,A,ACKK )(5(9(9CGG   %*7*=*=CII   '  >sB$GB.I98I9cURnURnUR[5UlUR[ 5UlUR[ [45UlUR[5Ul UR[5Ul UR[5UlURSSS5nX0lUR["SS5UlUR[&SS5UlUR[*SS5UlUR[.S S 5UlUR[2S S 5UlUR[6S S5UlUR[:SS5UlUR[>SS5Ul UR[BSS5Ul"UR[FSS5Ul$UR[JSS5Ul&UR[NSS5Ul(UR[RSS5Ul*URW[XRZ[XR\5Ul/URW[XR`[XRb5Ul2URW[XRf[XRh5Ul5URW[XRl[XRn5Ul8URW[XRr[XRt5Ul;URW[XRx[XRz5Ul>URW[XR~[XR5UlAURW[XR[XR5UlDURW[XR[XR5UlGURW[XR[XR5UlJURW[XR[XR5UlMURW[XR[XR5UlPURW[XR[XR5UlSURW[XR[XR5UlVURW[XR[XR5UlYURW[XRl[XRn5Ul8URW[XR[XR5Ul\URW[XR[XR5Ul_URW[XR[XR5UlbURW[XR[XR5UleURW[XR[XR5UlhURW[XR[XR5UlkURW[XR[XR5UlnURW[XR[XR5UlqURW[XR[XR5UltURW[XR[XR5=UlwUlxURW[XR[XR5Ul{URW[XR[XR5Ul~URW[XR[XGR5UlURW[XGR[XGR5=UlUlURW[XGR [XGR5UlURW[XGR[XGR5UlURW[XGR[XGR5UlURW[XGR[XGR 5UlURW[XGR$[XGR&5UlURW[XGR*[XGR,5UlURW[XGR0[XGR25UlURW[XGR6[XGR85UlURW[XGR<[XGR>5UlURW[XGRBS5UlURW[XGRFS5UlURW[XGRJ[XGRL5UlURW[XGRP[XGRR5UlG[WUSUR^5Ul/G[WUSURv5Ul;G[WUSURj5Ul5G[WUS UR5UlGG[WUS!UR5UlDg)"NcS[SU- S4$)Nrr)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' constantmertens _sage_sqrt _sage_exp_sage_ln _sage_cos _sage_sin)rorpmake_mpfroner zeromake_mpcjr!infr"ninfr#nanrqrrPrrTrrUrrSrrRrrVrrWrrYrrZrrXrrQrr[rr\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)rrorprs rrvMPContext.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$URU5$N)r9)rxrs rr9MPContext.to_fixedszz$rcURU5nURU5nUR[R"URUR/UR Q765$)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?QRSSrc>[URU55nUS:XaURU5$[US5(d[eUR up4[ R"XRX4SS9upVUcURU5$URXV45$)Nrr/T)r) int_rer hasattrNotImplementedErrorr0r mpf_expintr/rrrnzrroundingrealimags r_gamma_upper_intMPContext._gamma_upper_ints  O 666!9 q'""% %++%%a$M  <<<% %<< - -rc"[U5nUS:XaURU5$[US5(d[eURup4[ R "XRX45upVUcURU5$URXV45$)Nrr/) r5r r7r8r0rr9r/rrr:s r _expint_intMPContext._expint_ints} F 666!9 q'""% %++%%a$A  <<<% %<< - -rc[US5(a<UR[R"URU/UR Q765$URnUR[R"X/UR Q765$![ a1 UR(aeUR[R4nNjf=fNr/) r7rr mpf_nthrootr/r0rrmr _mpc_r mpc_nthrootrr*r;s r_nthrootMPContext._nthroots 1g   +||E$5$5aggq$V3CUCU$VWW A||E--aHS5G5GHII ! +##WWekk* +s:B 8CCc$URup4[US5(a0UR[R"XR X455$[US5(a0UR [R"XRX455$gNr/rH) r0r7rr mpf_besseljnr/r mpc_besseljnrH)rr;r<rr=s r_besseljMPContext._besseljsn++ 1g  << 2 21ggt NO O Q << 2 21ggt NO O!rc2URup4[US5(aO[US5(a>[R"URURX45nUR U5$[US5(aUR[R4nO URn[US5(aUR[R4nO URnUR[R"XX455$![ a Nf=frF) r0r7rmpf_agmr/rrr rHrmpc_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/rHFzisnan() needs a number as input) r7r/r#rH isinstancer r^rsr-isnan TypeErrorrs rrMPContext.isnan>s" 1g  77d? " 1g  177? " a # #z!X\\'B'B KKN 1g  '!W"5"599Q< 9::rc^URU5(dURU5(agg)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<<rcU(dg[US5(aURup#pEU=(a US:$[US5(a3UR(+=(a URUR5$[ U5[ ;aUS:*$[XR5(a'URupgU(dgUS:H=(a US:*$URURU55$)z, Determine if *x* is a nonpositive integer. Tr/rrHr) r7r/r?isnpintr>rmr rrs_mpq_r-)rr*signmanrbcpqs rrMPContext.isnpintts 1g  !" Ds$C1H $ 1g  vv:5#++aff"5 5 7i 6M a ! !77DA6$a1f ${{3;;q>**rcSSUR-RS5S-SUR-RS5S-SUR-RS5S-/nS R U5$) NzMpmath settings:z mp.prec = %sz [default: 53]z mp.dps = %sz [default: 15]z mp.trap_complex = %sz[default: False] )rljustdpsrmjoin)rliness r__str__MPContext.__str__st#  ( / / 3o E sww & - -b 1O C %(8(8 8 ? ? CFX X  yyrc,[UR5$r))r _precrs r _repr_digitsMPContext._repr_digitss ""rcUR$r))_dpsrs r _str_digitsMPContext._str_digitss xxrFc(^[UU4SjSU5$)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>UT-$r)rr;s rr%MPContext.extraprec..s q1urNPrecisionManagerrr;normalize_outputs ` r extraprecMPContext.extraprecs  _dUT-$r)rdr;s rr$MPContext.extradps..s QUrrrs ` 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>T$r)rrs rr$MPContext.workprec..sqrNrrs ` rworkprecMPContext.workprecs [$8HIIrc(^[USU4SjU5$)z} This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. Nc>T$r)rrs rr#MPContext.workdps..sQrrrs ` rworkdpsMPContext.workdpss  T;8HIIrNrc$^^^^^UUUUU4SjnU$)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>>T RnT cT RU5nOT nUS-T lT "U0UD6nUS-nUT lT "U0UD6nXF:XaOT RXd- 5T RU5- nXr*:aOXT (a[ SU<SU<SU*<35 UnXS:aT R SU-5eU[ US-5- n[XS5nMUT lU7$!Ta T RnNf=f!Ta T RnNf=f!UT lf=f)N zautoprec: target=z, prec=z , accuracy=z2autoprec: prec increased to %i without convergence)r_default_hyper_maxprecrmagprint NoConvergencer5min) argsrrrmaxprec2v1prec2v2errcatchrfmaxprecverboses rf_autoprec_wrapped.MPContext.autoprec..f_autoprec_wrapped sU88D55d;" "9!D+F+Br $CH%//x''"%.3772;6Ce}#USD23B(!//L !!Sq\)E0E), 3J5!B!!% WW%$ sR DC# DC;B D#C85D7C88D;D DDD Dr)rrrrrrs````` rautoprecMPContext.autoprecsH$ $ J"!rc :^^^[U[5(a SSRUUU4SjU55-$[U[5(a SSRUUU4SjU55-$[ US5(a[ UR T40TD6$[ US5(aS[URT40TD6-S -$[U[5(a [U5$[UTR5(aUR"T40TD6$[U5$) 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># UHnTR"UT40TD6v M g7fr)nstr.0rsrrrr;s r !MPContext.nstr..]!&KAsxx1'?'?!$z(%s)c3L># UHnTR"UT40TD6v M g7fr)rrs rrr_rrr/rH())rlistrtupler7rr/r:rHrreprmatrix__nstr__str)rr*r;rrs` ``rrMPContext.nstr4sP a  TYY&K&KKL L a  TYY&K&KKL L 1g  !''1// / 1g  AGGQ9&99S@ @ a $ $7N a $ $::a*6* *1v rcNU(a[U[5(aSUR5;aUR5RSS5n[R U5nUR S5nU(dSnUR S5RS5nURURU5URU55$[US5(a/URupgXg:XaURU5$[S5e[S [U5-5e) Nr rerim_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rrlowerreplace get_complexmatchgrouprstriprpr-r7rr ValueErrorrr)rr*stringsrrrrVrWs r_convert_fallbackMPContext._convert_fallbackjs z!Z00aggiGGI%%c2.#))!,[[&B[[&--c2wws{{2 B@@ 1g  77DAv||A& !OPP1DG;< ! &Um''>!"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 [US5(aXUS4nURn O"[US5(aXUS4nURn WUR;a&[R "U5SURU'URUn UR n URSURU 55n Sn Sn0nS n[U5HunnUUS :XaWUU:aOUS ::aIS n[USU5H#unnUUS :XdMUS ::dMUU::dM!S nM% U(d [S 5eMfURU5unn[U5*nU*nUU:a7US :a1US:a+UU;aUU==U- ss'OUUU'[U UU - S-5n U[U5- nM X:a[UR XU -4-5eX-nU(a[#SU55nO0nU "UW U UUU40UD6unnnU*nS nU U:a$UR%5HnUbUU :dMS n O UU S- S- :=(d U(+nU(aFU(aOOURS5n U b*UU :a$U(aUR'S 5$UR($U S-n US- nU S- n M[+U5[,La)U(aUR/U5$UR1U5$U$)Nr/RrHCrr2rZFTzpole in hypergeometric series<c3(# UHoS4v M g7fr)r)rr;s rr#MPContext.hypsum..sB/Q4/szeroprecr)r7r/rHrwrmake_hyp_summatorrrr enumerateZeroDivisionError nint_distancer5maxabsr _hypsum_msgdictvaluesrprrmrrr)!rrrflagscoeffsr<accurate_smallrrkeyrXsummatorrrrepsshiftmagnitude_checkmax_total_jumpirsokiiccr;rwpmag_dictzv have_complex magnitudecanceljumps_resolvedaccuraters! rhypsumMPContext.hypsums  1g  s"CA Q s"CA c'' '%*%<%)!*A q4x).+2a/E~3EH!::j1'('#&771:-#&88O NI MH NIGJ 8u ||B''||B''IrcURU5nUR[R"URU55$)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/rJs rldexpMPContext.ldexps/ KKN||EOOAGGQ788rcURU5n[R"UR5up#UR U5U4$)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*r1r;s rfrexpMPContext.frexps8 KKNqww'||A!!rc 8URU5up4URU5n[US5(a%UR[ UR X455$[US5(a%UR [URX455$[S5e)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/rH2Arguments need to be mpf or mpc compatible numbers) rnr-r7rr&r/rr?rHr)rr*rrrr=s rfnegMPContext.fnegs|\0 KKN 1g  << @A A 1g  << @A AMNNrc "URU5upEURU5nURU5n[US5(a[US5(a0UR[ UR UR XE55$[US5(a0UR [URUR XE55$[US5(a[US5(a0UR [URUR XE55$[US5(a0UR [URURXE55$[S5e![[4a [UR5ef=f)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/rHr>) rnr-r7rr'r/rrCrHrBr OverflowError_exact_overflow_msgrr*r1rrrr=s rfaddMPContext.faddFs7p0 KKN KKN 9q'""1g&&<<$(QRR1g&&<< AGGQWWd(UVVq'""1g&&<< AGGQWWd(UVV1g&&<<$(QRRMNNM* 9 7 78 8 9!AE( AE( AE(AE((&Fc .URU5upEURU5nURU5n[US5(a[US5(a0UR[ UR UR XE55$[US5(a6UR [UR [4URXE55$[US5(a[US5(a0UR [URUR XE55$[US5(a0UR [URURXE55$[S5e![[4a [UR5ef=f)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/rHr>)rnr-r7rr(r/rrDr rHrErrBrCrDs rfsubMPContext.fsubs<`0 KKN KKN 9q'""1g&&<<$(QRR1g&&<<%0@!''4(Z[[q'""1g&&<< AGGQWWd(UVV1g&&<<$(QRRMNNM* 9 7 78 8 9s!AE. AE.AE."AE..&Fc "URU5upEURU5nURU5n[US5(a[US5(a0UR[ UR UR XE55$[US5(a0UR [URUR XE55$[US5(a[US5(a0UR [URUR XE55$[US5(a0UR [URURXE55$[S5e![[4a [UR5ef=f)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/rHr>) rnr-r7rr)r/rrGrHrFrrBrCrDs rfmulMPContext.fmuls7f0 KKN KKN 9q'""1g&&<<$(QRR1g&&<< AGGQWWd(UVVq'""1g&&<< AGGQWWd(UVV1g&&<<$(QRRMNNM* 9 7 78 8 9rGc URU5upEU(d [S5eURU5nURU5n[US5(a[US5(a0UR [ UR UR XE55$[US5(a6UR[UR [4URXE55$[US5(a[US5(a0UR[URUR XE55$[US5(a0UR[URURXE55$[S5e)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/rHr>) rnrr-r7rr+r/rrIr rHrJrDs rfdivMPContext.fdivsb0AB B KKN KKN 1g  q'""||GAGGQWWd$MNNq'""||GQWWe,U*S- nUU- nUS-(aUS- nUU-U- nOUUU--nUS- nU[U5-nU(aU*nO$U[:XaURnSnO [S5eU[%UU 54$) 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/rHzrequires a finite numberzrequires an mpf/mpcr)rmr r5rr^rsrdivmodr8rr7r/rHr rr-rrr)rr*typxrrr;rrrim_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)rfactorsorigrXrs rfprodMPContext.fprodsCxx AHr Hs08cJUR[UR55$)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. )rr6rrs rrandMPContext.rands ||HSYY/00rcB^^URUU4SjT<ST<35$)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>[TTX5$r))r)rrrrs rr$MPContext.fraction..smAq$.Lr/)rq)rrrs ``rfractionMPContext.fractions!$||L!  rc6[URU55$r)rr-rs rabsminMPContext.absmin3;;q>""rc6[URU55$r)rmrs rabsmaxMPContext.absmaxrprc[US5(a0URup#URU5URU5/$U$)Nr)r7rr)rr*rVrWs r _as_pointsMPContext._as_pointss: 1g  77DALLOS\\!_5 5rrcnURU5(a[US5(d[e[U5nURn[ R "URX#XEU5upxUV s/sHoRU 5PM nn UV s/sHoRU 5PM nn Xx4$s sn fs sn f)NrH) isintr7r8r5rr mpc_zetasumrHr) rrtrVr; derivativesreflectrxsysr*r1s r _zetasum_fastMPContext._zetasum_fast s ! G!4!4% % Fyy""177A+M') *r!ll1or *') *r!ll1or *v + *s .B-B2)rF)NrF))T):__name__ __module__ __qualname____firstlineno____doc__rlrvr9r2r@rCrKrQrYryrar~r}rurzr~rgrrrrrpropertyrrrrrrrrrrrnrCrr3r7r;r?rErIrLrOrrardrjrnrrrur~__static_attributes__rrrrgrg:s\1BT5l T . . JP ANMT P > >  ;84+( ##N$NJ"Ji"V4l=$,"*DKSj9"" 4OlHOT@ODCOJ@OD`(D*1*##"23Urrgc0\rSrSrSSjrSrSrSrSrg) ric4XlX lX0lX@lgr))rprecfundpsfunr)selfrrrrs rrlPrecisionManager.__init__s  0rcJ^^[R"T5UU4Sj5nU$)Ncf>TRRnTR(a5TRTRR5TRlO4TRTRR5TRlTR (a[T"U0UD6n[ U5[La-[UVs/sHoD7PM sn5UTRl$U7UTRl$T"U0UD6UTRl$s snf!UTRlf=fr))rrrrrrrmr)rrrr`rXrVrrs rg$PrecisionManager.__call__..gs88==D %<<$(LL$?DHHM#';;txx||#r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r^object__new__newcompilersage.libs.mpmath.ext_mainr`rklibsmpmathext_main _mpf_modulerbrarcrdrergrrdoctesttestmodrrrrs   ).. nnjjKL  fB33?.00Y 2Yv&!!H z OOr