ó 'kº[c@sSdZdZddlZddlmZddlmZmZddlm Z ddl m Z 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;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m Z dd lm^Z^dd lm_Z_e`jaZbejcd ƒZded krÂdd lemfZgddlejhjijjZkn ddllmmZgddlmlZkddllmnZnmoZompZpdegefd„ƒYZqdfd„ƒYZresdkrOddltZtetjuƒndS(s[ This module defines the mpf, mpc classes, and standard functions for operating with them. t plaintextiÿÿÿÿNi(tStandardBaseContext(t basestringtBACKEND(tlibmp(UtMPZtMPZ_ZEROtMPZ_ONEt int_typestrepr_dpst round_floort round_ceilingt dps_to_prect round_nearestt prec_to_dpst ComplexResultt to_pickablet from_pickablet normalizetfrom_intt from_floattfrom_strtto_inttto_floattto_strt from_rationalt from_man_exptfonetfzerotfinftfninftfnantmpf_abstmpf_postmpf_negtmpf_addtmpf_subtmpf_mult mpf_mul_inttmpf_divt mpf_rdiv_intt mpf_pow_inttmpf_modtmpf_eqtmpf_cmptmpf_lttmpf_gttmpf_letmpf_getmpf_hashtmpf_randtmpf_sumtbitcounttto_fixedt mpc_to_strtmpc_to_complextmpc_hashtmpc_postmpc_is_nonzerotmpc_negt mpc_conjugatetmpc_abstmpc_addt mpc_add_mpftmpc_subt mpc_sub_mpftmpc_mult mpc_mul_mpft mpc_mul_inttmpc_divt mpc_div_mpftmpc_powt mpc_pow_mpft mpc_pow_intt mpc_mpf_divtmpf_powtmpf_pit mpf_degreetmpf_etmpf_phitmpf_ln2tmpf_ln10t mpf_eulert mpf_catalant mpf_aperyt mpf_khinchint mpf_glaishert mpf_twinprimet mpf_mertensR(t function_docs(trationalsX^\(?(?P[\+\-]?\d*\.?\d*(e[\+\-]?\d+)?)??(?P[\+\-]?\d*\.?\d*(e[\+\-]?\d+)?j)?\)?$tsage(tContext(tPythonMPContext(t ctx_mp_python(t_mpft_mpct mpnumerict MPContextcBseZdZd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z d d „Z d „Z d „Z d „Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zed„ƒZed„ƒZed„Zed„Zed„Zed„Z d7d8ed„Z"dd „Z#d!„Z$d"„Z%d#„Z&d$Z'd%Z(e)d&„Z*d'„Z+d(„Z,d)„Z-d*„Z.d+„Z/d,„Z0d-„Z1d.„Z2d/„Z3d0„Z4d1„Z5d2„Z6d3„Z7d4„Z8d5ged6„Z9RS(9sH Context for multiprecision arithmetic with a global precision. cCs_tj|ƒt|_t|_|j|j|jg|_t j |_ |j ƒt j|ƒt j |_ |jƒi|_|jƒyLtj|jj_tj|jj_tj|jj_tj|jj_WnYtk r-tj|jj_tj|jj_tj|jj_tj|jj_nXtj|j_tj|j_tj|j_dS(N(t BaseMPContextt__init__tFalset trap_complextprettytmpftmpctconstantttypesRZtmpqt_mpqtdefaultRt init_builtinst hyp_summatorst _init_aliasesRYt bernoullitim_functfunc_doctprimepitpsitatan2tAttributeErrort__func__tdigammatcospitsinpi(tctx((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRd=s0           cCs'|j}|j}|jtƒ|_|jtƒ|_|jttfƒ|_|jt ƒ|_ |jt ƒ|_ |jt ƒ|_|jd„ddƒ}||_|jtddƒ|_|jtddƒ|_|jtddƒ|_|jtd d ƒ|_|jtd d ƒ|_|jtd dƒ|_|jtddƒ|_|jtddƒ|_ |jt!ddƒ|_"|jt#ddƒ|_$|jt%ddƒ|_&|jt'ddƒ|_(|jt)ddƒ|_*|j+t,j-t,j.ƒ|_/|j+t,j0t,j1ƒ|_2|j+t,j3t,j4ƒ|_5|j+t,j6t,j7ƒ|_8|j+t,j9t,j:ƒ|_;|j+t,j<t,j=ƒ|_>|j+t,j?t,j@ƒ|_A|j+t,jBt,jCƒ|_D|j+t,jEt,jFƒ|_G|j+t,jHt,jIƒ|_J|j+t,jKt,jLƒ|_M|j+t,jNt,jOƒ|_P|j+t,jQt,jRƒ|_S|j+t,jTt,jUƒ|_V|j+t,jWt,jXƒ|_Y|j+t,j6t,j7ƒ|_8|j+t,jZt,j[ƒ|_\|j+t,j]t,j^ƒ|__|j+t,j`t,jaƒ|_b|j+t,jct,jdƒ|_e|j+t,jft,jgƒ|_h|j+t,jit,jjƒ|_k|j+t,jlt,jmƒ|_n|j+t,jot,jpƒ|_q|j+t,jrt,jsƒ|_t|j+t,jut,jvƒ|_w|_x|j+t,jyt,jzƒ|_{|j+t,j|t,j}ƒ|_~|j+t,jt,j€ƒ|_|j+t,j‚t,jƒƒ|_„|_…|j+t,j†t,j‡ƒ|_ˆ|j+t,j‰t,jŠƒ|_‹|_Œ|j+t,jt,jŽƒ|_|j+t,jt,j‘ƒ|_’|j+t,j“t,j”ƒ|_•|j+t,j–t,j—ƒ|_˜|j+t,j™t,jšƒ|_›|j+t,jœt,jƒ|_ž|j+t,jŸt,j ƒ|_¡|j+t,j¢t,j£ƒ|_¤|j+t,j¥t,j¦ƒ|_§|j+t,j¨dƒ|_ª|j+t,j«dƒ|_¬|j+t,j­t,j®ƒ|_¯|j+t,j°t,j±ƒ|_²t³|d|j/ƒ|_/t³|d|j;ƒ|_;t³|d|j5ƒ|_5t³|d |jGƒ|_Gt³|d!|jDƒ|_DdS("NcSsdtd|dfS(Nii(R(tprectrnd((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytkssepsilon of working precisiontepstpisln(2)tln2sln(10)tln10sGolden ratio phitphis e = exp(1)tesEuler's constantteulersCatalan's constanttcatalansKhinchin's constanttkhinchinsGlaisher's constanttglaishersApery's constanttaperys1 deg = pi / 180tdegreesTwin prime constantt twinprimesMertens' constanttmertenst _sage_sqrtt _sage_expt_sage_lnt _sage_cost _sage_sin(´RhRitmake_mpfRtoneRtzerotmake_mpctjRtinfRtninfRtnanRjRRLR‚RPRƒRQR„ROR…RNR†RRR‡RSRˆRUR‰RVRŠRTR‹RMRŒRWRRXRŽt_wrap_libmp_functionRtmpf_sqrttmpc_sqrttsqrttmpf_cbrttmpc_cbrttcbrttmpf_logtmpc_logtlntmpf_atantmpc_atantatantmpf_exptmpc_exptexptmpf_expjtmpc_expjtexpjt mpf_expjpit mpc_expjpitexpjpitmpf_sintmpc_sintsintmpf_costmpc_costcostmpf_tantmpc_tanttantmpf_sinhtmpc_sinhtsinhtmpf_coshtmpc_coshtcoshtmpf_tanhtmpc_tanhttanhtmpf_asintmpc_asintasintmpf_acostmpc_acostacost mpf_asinht mpc_asinhtasinht mpf_acosht mpc_acoshtacosht mpf_atanht mpc_atanhtatanht mpf_sin_pit mpc_sin_piR|t mpf_cos_pit mpc_cos_piR{t mpf_floort mpc_floortfloortmpf_ceiltmpc_ceiltceiltmpf_ninttmpc_ninttninttmpf_fractmpc_fractfract mpf_fibonaccit mpc_fibonaccitfibt fibonaccit mpf_gammat mpc_gammatgammat mpf_rgammat mpc_rgammatrgammat mpf_loggammat mpc_loggammatloggammat mpf_factorialt mpc_factorialtfact factorialt mpf_gamma_oldt mpc_gamma_oldt gamma_oldtmpf_factorial_oldtmpc_factorial_oldtfac_oldt factorial_oldtmpf_psi0tmpc_psi0Rzt mpf_harmonict mpc_harmonictharmonictmpf_eitmpc_eiteitmpf_e1tmpc_e1te1tmpf_citmpc_cit_citmpf_sitmpc_sit_sit mpf_ellipkt mpc_ellipktellipkt mpf_ellipet mpc_ellipet_ellipetmpf_agm1tmpc_agm1tagm1tmpf_erftNonet_erftmpf_erfct_erfctmpf_zetatmpc_zetat_zetat mpf_altzetat mpc_altzetat_altzetatgetattr(R}RhRiR((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRo^s”     """cCs |j|ƒS(N(R5(R}txR~((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR5¶scCsC|j|ƒ}|j|ƒ}|jtj|j|j|jŒƒS(s€ Computes the Euclidean norm of the vector `(x, y)`, equal to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real.(tconvertR”Rt mpf_hypott_mpf_t_prec_rounding(R}R!ty((s,lib/python2.7/site-packages/mpmath/ctx_mp.pythypot¹scCs¬t|j|ƒƒ}|dkr.|j|ƒSt|dƒsFt‚n|j\}}tj||j||dt ƒ\}}|dkr•|j |ƒS|j ||fƒSdS(NiR$Ré( tintt_reRthasattrtNotImplementedErrorR%Rt mpf_expintR$tTrueRR”R—(R}tntzR~troundingtrealtimag((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt_gamma_upper_intÁs   '  cCst|ƒ}|dkr%|j|ƒSt|dƒs=t‚n|j\}}tj||j||ƒ\}}|dkr†|j |ƒS|j ||fƒSdS(NiR$( R(RR*R+R%RR,R$RR”R—(R}R.R/R~R0R1R2((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt _expint_intÎs    !  cCs•t|dƒrmy&|jtj|j||jŒƒSWqvtk ri|jrT‚n|jtjf}qvXn |j }|j tj |||jŒƒS(NR$( R*R”Rt mpf_nthrootR$R%RRfRt_mpc_R—t mpc_nthroot(R}R!R.((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt_nthrootÛs&   cCsu|j\}}t|dƒr@|jtj||j||ƒƒSt|dƒrq|jtj||j||ƒƒSdS(NR$R6( R%R*R”Rt mpf_besseljnR$R—t mpc_besseljnR6(R}R.R/R~R0((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt_besseljçs "icCsì|j\}}t|dƒrst|dƒrsy/tj|j|j||ƒ}|j|ƒSWqstk roqsXnt|dƒr—|jtjf}n |j}t|dƒrÄ|jtjf}n |j}|j tj ||||ƒƒS(NR$( R%R*Rtmpf_agmR$R”RRR6R—tmpc_agm(R}tatbR~R0tv((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt_agmîs   cCs"|jtjt|ƒ|jŒƒS(N(R”Rt mpf_bernoulliR(R%(R}R.((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRrüscCs"|jtjt|ƒ|jŒƒS(N(R”Rt mpf_zeta_intR(R%(R}R.((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt _zeta_intÿscCsC|j|ƒ}|j|ƒ}|jtj|j|j|jŒƒS(N(R"R”Rt mpf_atan2R$R%(R}R&R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRwscCsr|j|ƒ}t|ƒ}|j|ƒrL|jtj||j|jŒƒS|jtj ||j |jŒƒSdS(N( R"R(t _is_real_typeR”Rtmpf_psiR$R%R—tmpc_psiR6(R}tmR/((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRvs  "cKsôt|ƒ|jkr'|j|ƒ}n|j|ƒ\}}t|dƒr…tj|j||ƒ\}}|j|ƒ|j|ƒfSt|dƒrÎtj |j ||ƒ\}}|j |ƒ|j |ƒfS|j |||j ||fSdS(NR$R6(ttypeRkR"t _parse_precR*Rt mpf_cos_sinR$R”t mpc_cos_sinR6R—R·R´(R}R!tkwargsR~R0tcts((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytcos_sinscKsôt|ƒ|jkr'|j|ƒ}n|j|ƒ\}}t|dƒr…tj|j||ƒ\}}|j|ƒ|j|ƒfSt|dƒrÎtj |j ||ƒ\}}|j |ƒ|j |ƒfS|j |||j ||fSdS(NR$R6(RJRkR"RKR*Rtmpf_cos_sin_piR$R”tmpc_cos_sin_piR6R—R·R´(R}R!RNR~R0RORP((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt cospi_sinpiscCs|jƒ}|j|_|S(sP Create a copy of the context, with the same working precision. (t __class__R~(R}R>((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytclone)s  cCs)t|dƒs!t|ƒtkr%tStS(NR6(R*RJtcomplexReR-(R}R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRF4s!cCs)t|dƒs!t|ƒtkr%tStS(NR6(R*RJRWR-Re(R}R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt_is_complex_type9s!cCs§t|dƒr|jtkSt|dƒr8t|jkSt|tƒsYt|tjƒr]tS|j |ƒ}t|dƒsŠt|dƒr—|j |ƒSt dƒ‚dS(s¢ 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$R6sisnan() needs a number as inputN( R*R$RR6t isinstanceRRZRlReR"tisnant TypeError(R}R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRZ>s  ! cCs&|j|ƒs|j|ƒr"tStS(sè 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 (tisinfRZReR-(R}R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytisfiniteZscCsÚ|s tSt|dƒr>|j\}}}}|o=|dkSt|dƒrg|j of|j|jƒSt|ƒtkrƒ|dkSt||j ƒrÄ|j \}}|s®tS|dkoÃ|dkS|j|j |ƒƒS(s< Determine if *x* is a nonpositive integer. R$iR6i( R-R*R$R2tisnpintR1RJRRYRlt_mpq_R"(R}R!tsigntmanR«tbctptq((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR^ts cCs[dd|jjdƒdd|jjdƒdd|jjdƒdg}d j|ƒS( NsMpmath settings:s mp.prec = %sis [default: 53]s mp.dps = %ss [default: 15]s mp.trap_complex = %ss[default: False]s (R~tljusttdpsRftjoin(R}tlines((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt__str__ˆs cCs t|jƒS(N(R t_prec(R}((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt _repr_digitsscCs|jS(N(t_dps(R}((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt _str_digits”scst|‡fd†d|ƒS(sÛ 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|ˆS(N((Rc(R.(s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR€¨sN(tPrecisionManagerR(R}R.tnormalize_output((R.s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt extraprec˜scst|d‡fd†|ƒS(s– This function is analogous to extraprec (see documentation) but changes the decimal precision instead of the number of bits. cs|ˆS(N((td(R.(s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR€¯sN(RnR(R}R.Ro((R.s,lib/python2.7/site-packages/mpmath/ctx_mp.pytextradpsªscst|‡fd†d|ƒS(s» 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. csˆS(N((Rc(R.(s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR€ÀsN(RnR(R}R.Ro((R.s,lib/python2.7/site-packages/mpmath/ctx_mp.pytworkprec±scst|d‡fd†|ƒS(s• This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. csˆS(N((Rq(R.(s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR€ÇsN(RnR(R}R.Ro((R.s,lib/python2.7/site-packages/mpmath/ctx_mp.pytworkdpsÂscs‡‡‡‡‡fd†}|S(s‹ 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 csrˆj}ˆdkr'ˆj|ƒ}nˆ}z3|dˆ_yˆ||Ž}Wnˆk rlˆj}nX|d}xå|ˆ_yˆ||Ž}Wnˆk r²ˆj}nX||krÃPnˆj||ƒˆj|ƒ}|| krôPnˆrd||| fGHn|}||kr8ˆjd|ƒ‚n|t|dƒ7}t||ƒ}qzWWd|ˆ_X| S(Ni is)autoprec: target=%s, prec=%s, accuracy=%ss2autoprec: prec increased to %i without convergencei(R~Rt_default_hyper_maxprecR›tmagt NoConvergenceR(tmin(targsRNR~tmaxprec2tv1tprec2tv2terr(tcatchR}tftmaxprectverbose(s,lib/python2.7/site-packages/mpmath/ctx_mp.pytf_autoprec_wrapped sD               ((R}R€RRR‚Rƒ((RR}R€RR‚s,lib/python2.7/site-packages/mpmath/ctx_mp.pytautoprecÉsD%ic sýt|tƒr6ddj‡‡‡fd†|DƒƒSt|tƒrlddj‡‡‡fd†|DƒƒSt|dƒrŽt|jˆˆSt|dƒr¸dt|jˆˆd St|t ƒrÑt |ƒSt|ˆj ƒró|j ˆˆSt |ƒS( s3 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' s[%s]s, c3s$|]}ˆj|ˆˆVqdS(N(tnstr(t.0RO(R}RNR.(s,lib/python2.7/site-packages/mpmath/ctx_mp.pys ]ss(%s)c3s$|]}ˆj|ˆˆVqdS(N(R…(R†RO(R}RNR.(s,lib/python2.7/site-packages/mpmath/ctx_mp.pys _sR$R6t(t)(RYtlistRgttupleR*RR$R6R6Rtreprtmatrixt__nstr__tstr(R}R!R.RN((R}RNR.s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR…4s('' cCs |r©t|tƒr©d|jƒkr©|jƒjddƒ}tj|ƒ}|jdƒ}|sld}n|jdƒjdƒ}|j|j |ƒ|j |ƒƒSnt |dƒrï|j \}}||krà|j |ƒSt dƒ‚ntd t|ƒƒ‚dS( NR˜t ttreitimt_mpi_s,can only create mpf from zero-width intervalscannot create mpf from (RYRtlowertreplacet get_complextmatchtgrouptrstripRiR"R*R“R”t ValueErrorR[R‹(R}R!tstringsR—R‘R’R>R?((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt_convert_fallbackjs %  cOs|j||ŽS(N(R"(R}RyRN((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt mpmathify|scCsÂ|r»|jdƒrdS|j\}}d|krA|d}nd|kry|d}||jkrjdSt|ƒ}n8d|kr±|d}||jkr¢d St|ƒ}n||fS|jS( NtexactiR€R0R~Rf(iR€(iR€(iR€(tgetR%R™R(R (R}RNR~R0Rf((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRKs$       s'the exact result does not fit in memorysœhypsum() 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!KsØt|dƒr-|||df}|j} n-t|dƒrZ|||df}|j} n||jkr†tj|ƒd|j|Çsitzeropreci(R*R$R6RpRtmake_hyp_summatorR~RŸRut enumerateReR-tZeroDivisionErrort nint_distanceR(tmaxtabsRšt _hypsum_msgtdicttvaluesRRiR–RJRŠR—R”(!R}RcRdtflagstcoeffsR/taccurate_smallRNtkeyR@tsummatorR~RRptepsshifttmagnitude_checktmax_total_jumptiROtoktiitccR.Rqtwptmag_dicttzvt have_complext magnitudetcanceltjumps_resolvedtaccurateR£((s,lib/python2.7/site-packages/mpmath/ctx_mp.pythypsumšsˆ    (  $             cCs+|j|ƒ}|jtj|j|ƒƒS(s– 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"R”Rt mpf_shiftR$(R}R!R.((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytldexpïscCs:|j|ƒ}tj|jƒ\}}|j|ƒ|fS(s= 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"Rt mpf_frexpR$R”(R}R!R&R.((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfrexps cKsŠ|j|ƒ\}}|j|ƒ}t|dƒrO|jt|j||ƒƒSt|dƒrz|jt|j||ƒƒSt dƒ‚dS(s 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$R6s2Arguments need to be mpf or mpc compatible numbersN( RKR"R*R”R"R$R—R;R6Rš(R}R!RNR~R0((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfnegs.cKsX|j|ƒ\}}|j|ƒ}|j|ƒ}yìt|dƒrªt|dƒrv|jt|j|j||ƒƒSt|dƒrª|jt|j|j||ƒƒSnt|dƒrt|dƒrê|jt|j|j||ƒƒSt|dƒr|jt |j|j||ƒƒSnWn&t t fk rGt |j ƒ‚nXt dƒ‚dS(s“ 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$R6s2Arguments need to be mpf or mpc compatible numbersN( RKR"R*R”R#R$R—R?R6R>Ršt OverflowErrort_exact_overflow_msg(R}R!R&RNR~R0((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfaddFs"8"%")cKs^|j|ƒ\}}|j|ƒ}|j|ƒ}yòt|dƒr°t|dƒrv|jt|j|j||ƒƒSt|dƒr°|jt|jtf|j ||ƒƒSnt|dƒr$t|dƒrð|jt |j |j||ƒƒSt|dƒr$|jt|j |j ||ƒƒSnWn&t t fk rMt |j ƒ‚nXt dƒ‚dS(s 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$R6s2Arguments need to be mpf or mpc compatible numbersN(RKR"R*R”R$R$R—R@RR6RARšRÇRÈ(R}R!R&RNR~R0((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfsubs"0"+")cKsX|j|ƒ\}}|j|ƒ}|j|ƒ}yìt|dƒrªt|dƒrv|jt|j|j||ƒƒSt|dƒrª|jt|j|j||ƒƒSnt|dƒrt|dƒrê|jt|j|j||ƒƒSt|dƒr|jt |j|j||ƒƒSnWn&t t fk rGt |j ƒ‚nXt dƒ‚dS(s¥ 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$R6s2Arguments need to be mpf or mpc compatible numbersN( RKR"R*R”R%R$R—RCR6RBRšRÇRÈ(R}R!R&RNR~R0((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfmulÒs"3"%")cKsF|j|ƒ\}}|s*tdƒ‚n|j|ƒ}|j|ƒ}t|dƒrÂt|dƒrˆ|jt|j|j||ƒƒSt|dƒrÂ|jt|jt f|j ||ƒƒSnt|dƒr6t|dƒr|jt |j |j||ƒƒSt|dƒr6|jt|j |j ||ƒƒSntdƒ‚dS(s© 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 s"division is not an exact operationR$R6s2Arguments need to be mpf or mpc compatible numbersN( RKRšR"R*R”R'R$R—RERR6RF(R}R!R&RNR~R0((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfdivs 1"+"%cCsÄt|ƒ}|tkr+t|ƒ|jfS|tjkr¼|j\}}t||ƒ\}}d||kr{|d7}n|sŽ||jfStt |||ƒƒt|ƒ}||fSt |dƒrà|j }|j} n°t |dƒrJ|j \}} | \} } } }| r#| |} q| t kr;|j} qtdƒ‚nF|j|ƒ}t |dƒswt |dƒr„|j|ƒStdƒ‚|\}}}}||}|dkrÇd}|}nê|r‡|dkrï||>}|j}n…|dkr|d?d}d}nb| d}||?}|d@rL|d7}||>|}n|||>8}|d?}|t|ƒ}|r±| }q±n*|t kr¥|j}d}n tdƒ‚|t|| ƒfS( sº 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 iiR$R6srequires a finite numbersrequires an mpf/mpciiÿÿÿÿ(RJRR(RšRZRlR_tdivmodR4R©R*R$R6RRšR"R§R[R¨(R}R!ttypxRcRdR.trRqR‘tim_distR’tisigntimantiexptibcR`RaR«RbRvtre_disttt((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR§Ysl!    $                          cCsC|j}z(|j}x|D]}||9}qWWd||_X| S(sT 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') N(R~R•(R}tfactorstorigR@Rc((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytfprod»s    cCs|jt|jƒƒS(s· 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. (R”R2Rj(R}((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytrandÐscs&|j‡‡fd†dˆˆfƒS(s 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ˆˆ||ƒS(N(R(R~R(RcRd(s,lib/python2.7/site-packages/mpmath/ctx_mp.pyR€êss%s/%s(Rj(R}RcRd((RcRds,lib/python2.7/site-packages/mpmath/ctx_mp.pytfractionØscCst|j|ƒƒS(N(R©R"(R}R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytabsminíscCst|j|ƒƒS(N(R©R"(R}R!((s,lib/python2.7/site-packages/mpmath/ctx_mp.pytabsmaxðscCs>t|dƒr:|j\}}|j|ƒ|j|ƒgS|S(NR“(R*R“R”(R}R!R>R?((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt _as_pointsósic Cs±|j|ƒot|dƒs't‚nt|ƒ}|j}tj|j|||||ƒ\}}g|D]} |j| ƒ^qj}g|D]} |j| ƒ^qŒ}||fS(NR6( tisintR*R+R(RjRt mpc_zetasumR6R—( R}RPR>R.t derivativestreflectR~txstysR!R&((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt _zetasum_fast s   '""N((:t__name__t __module__t__doc__RdRoR5R'R3R4R8R;RARrRDRwRvRQRTRVRFRXRZR]R^RitpropertyRkRmReRpRrRsRtRR„R…RœRRKRÈRªR-RÁRÃRÅRÆRÉRÊRËRÌR§RÙRÚRÛRÜRÝRÞRå(((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRb8sh ! X                  k 6    U   6 J B E B b      RncBs/eZed„Zd„Zd„Zd„ZRS(cCs(||_||_||_||_dS(N(R}tprecfuntdpsfunRo(tselfR}RêRëRo((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRds   cs.‡‡fd†}ˆj|_ˆj|_|S(NcsÀˆjj}z ˆjr6ˆjˆjjƒˆj_nˆjˆjjƒˆj_ˆjržˆ||Ž}t|ƒtkr™tg|D] }| ^q…ƒS| Sˆ||ŽSWd|ˆj_XdS(N(R}R~RêRëRfRoRJRŠ(RyRNRØR@R>(R€Rì(s,lib/python2.7/site-packages/mpmath/ctx_mp.pytgs   (RæRè(RìR€Rí((R€Rìs,lib/python2.7/site-packages/mpmath/ctx_mp.pyt__call__s  cCsU|jj|_|jr6|j|jjƒ|j_n|j|jjƒ|j_dS(N(R}R~torigpRêRëRf(Rì((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt __enter__/s cCs|j|j_tS(N(RïR}R~Re(Rìtexc_typetexc_valtexc_tb((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyt__exit__5s(RæRçReRdRîRðRô(((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyRns   t__main__(vRèt __docformat__R‘tctx_baseRt libmp.backendRRRRRRRRR 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@RARBRCRDRERFRGRHRIRJRKRLRMRNRORPRQRRRSRTRURVRWRXRYRZtobjectt__new__tnewtcompileR–tsage.libs.mpmath.ext_mainR\Rctlibstmpmathtext_maint _mpf_moduleR^R]R_R`RaRbRnRætdoctestttestmod(((s,lib/python2.7/site-packages/mpmath/ctx_mp.pyts6 ÿÿ   ÿÿÿÿá%