o lÇ h,Áã@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`eajbZce dd ¡Zeed krùdd lfmgZhddlfmimjmkZln ddlmmnZhddl mmZlddlmmoZompZpmqZqGdd„deheƒZrGdd„dƒZsetdkr.ddluZueu v¡dSdS)z[ This module defines the mpf, mpc classes, and standard functions for operating with them. Ú plaintextéNé)ÚStandardBaseContext)Ú basestringÚBACKEND)Úlibmp)UÚMPZÚMPZ_ZEROÚMPZ_ONEÚ int_typesÚrepr_dpsÚ round_floorÚ round_ceilingÚ dps_to_precÚ round_nearestÚ prec_to_dpsÚ ComplexResultÚ to_pickableÚ from_pickableÚ normalizeÚfrom_intÚ from_floatÚfrom_strÚto_intÚto_floatÚto_strÚ from_rationalÚ from_man_expÚfoneÚfzeroÚfinfÚfninfÚfnanÚmpf_absÚmpf_posÚmpf_negÚmpf_addÚmpf_subÚmpf_mulÚ mpf_mul_intÚmpf_divÚ mpf_rdiv_intÚ mpf_pow_intÚmpf_modÚmpf_eqÚmpf_cmpÚmpf_ltÚmpf_gtÚmpf_leÚmpf_geÚmpf_hashÚmpf_randÚmpf_sumÚbitcountÚto_fixedÚ mpc_to_strÚmpc_to_complexÚmpc_hashÚmpc_posÚmpc_is_nonzeroÚmpc_negÚ mpc_conjugateÚmpc_absÚmpc_addÚ mpc_add_mpfÚmpc_subÚ mpc_sub_mpfÚmpc_mulÚ mpc_mul_mpfÚ mpc_mul_intÚmpc_divÚ mpc_div_mpfÚmpc_powÚ mpc_pow_mpfÚ mpc_pow_intÚ mpc_mpf_divÚmpf_powÚmpf_piÚ mpf_degreeÚmpf_eÚmpf_phiÚmpf_ln2Úmpf_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@sÂeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dmdd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zed/d0„ƒZed1d2„ƒZdnd4d5„Zdnd6d7„Zdnd8d9„Zdnd:d;„Z dod>d?„Z!dpdAdB„Z"dCdD„Z#dEdF„Z$dGdH„Z%dIZ&dJZ'dqdLdM„Z(dNdO„Z)dPdQ„Z*dRdS„Z+dTdU„Z,dVdW„Z-dXdY„Z.dZd[„Z/d\d]„Z0d^d_„Z1d`da„Z2dbdc„Z3ddde„Z4dfdg„Z5dhdi„Z6 djgd3fdkdl„Z7d| +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,j‚t,jƒ¡|_„|_…| +t,j†t,j‡¡|_ˆ| +t,j‰t,jŠ¡|_‹| +t,jŒt,j¡|_Ž| +t,jt,j¡|_‘| +t,j’t,j“¡|_”| +t,j•t,j–¡|_—| +t,j˜t,j™¡|_š| +t,j›t,jœ¡|_| +t,jžt,jŸ¡|_ | +t,j¡d¡|_¢| +t,j£d¡|_¤| +t,j¥t,j¦¡|_§| +t,j¨t,j©¡|_ªt«|d|j/ƒ|_/t«|d|j;ƒ|_;t«|d |j5ƒ|_5t«|d!|jGƒ|_Gt«|d"|jDƒ|_DdS)#NcSsdtd|dfS)Nrr)r ©ÚprecÚrndr‚r‚rƒÚmsz)MPContext.init_builtins..zepsilon of working precisionÚepsÚpizln(2)Úln2zln(10)Úln10zGolden ratio phiÚphiz e = exp(1)ÚezEuler's constantÚeulerzCatalan's constantÚcatalanzKhinchin's constantÚkhinchinzGlaisher's constantÚglaisherzApery's constantÚaperyz1 deg = pi / 180ÚdegreezTwin prime constantÚ twinprimezMertens' constantÚmertensÚ _sage_sqrtÚ _sage_expÚ_sage_lnÚ _sage_cosÚ _sage_sin)¬rkrlÚmake_mpfrÚonerÚzeroÚmake_mpcÚjr Úinfr!Úninfr"ÚnanrmrˆrOr‰rSrŠrTr‹rRrŒrQrrUrŽrVrrXrrYr‘rWr’rPr“rZr”r[r•Ú_wrap_libmp_functionrÚmpf_sqrtÚmpc_sqrtÚsqrtÚmpf_cbrtÚmpc_cbrtÚcbrtÚmpf_logÚmpc_logÚlnÚmpf_atanÚmpc_atanÚatanÚmpf_expÚmpc_expÚexpÚmpf_expjÚmpc_expjÚexpjÚ mpf_expjpiÚ mpc_expjpiÚexpjpiÚmpf_sinÚmpc_sinÚsinÚmpf_cosÚmpc_cosÚcosÚmpf_tanÚmpc_tanÚtanÚmpf_sinhÚmpc_sinhÚsinhÚmpf_coshÚmpc_coshÚcoshÚmpf_tanhÚmpc_tanhÚtanhÚmpf_asinÚmpc_asinÚasinÚmpf_acosÚmpc_acosÚacosÚ mpf_asinhÚ mpc_asinhÚasinhÚ mpf_acoshÚ mpc_acoshÚacoshÚ mpf_atanhÚ mpc_atanhÚatanhÚ mpf_sin_piÚ mpc_sin_pirÚ mpf_cos_piÚ mpc_cos_pir~Ú mpf_floorÚ mpc_floorÚfloorÚmpf_ceilÚmpc_ceilÚceilÚmpf_nintÚmpc_nintÚnintÚmpf_fracÚmpc_fracÚfracÚ mpf_fibonacciÚ mpc_fibonacciÚfibÚ fibonacciÚ mpf_gammaÚ mpc_gammaÚgammaÚ mpf_rgammaÚ mpc_rgammaÚrgammaÚ mpf_loggammaÚ mpc_loggammaÚloggammaÚ mpf_factorialÚ mpc_factorialÚfacÚ factorialÚmpf_psi0Úmpc_psi0r}Ú mpf_harmonicÚ mpc_harmonicÚharmonicÚmpf_eiÚmpc_eiÚeiÚmpf_e1Úmpc_e1Úe1Úmpf_ciÚmpc_ciÚ_ciÚmpf_siÚmpc_siÚ_siÚ mpf_ellipkÚ mpc_ellipkÚellipkÚ mpf_ellipeÚ mpc_ellipeÚ_ellipeÚmpf_agm1Úmpc_agm1Úagm1Úmpf_erfÚ_erfÚmpf_erfcÚ_erfcÚmpf_zetaÚmpc_zetaÚ_zetaÚ mpf_altzetaÚ mpc_altzetaÚ_altzetaÚgetattr)rrkrlrˆr‚r‚rƒrr`s’      ÿzMPContext.init_builtinscCs | |¡S©N)r8)rÚxr…r‚r‚rƒr8¶s zMPContext.to_fixedcCs4| |¡}| |¡}| tj|j|jg|j¢RŽ¡S)z€ Computes the Euclidean norm of the vector `(x, y)`, equal to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real.)Úconvertr›rÚ mpf_hypotÚ_mpf_Ú_prec_rounding)rr!Úyr‚r‚rƒÚhypot¹s   zMPContext.hypotcCsrt| |¡ƒ}|dkr| |¡St|dƒst‚|j\}}tj||j||dd\}}|dur2|  |¡S|  ||f¡S)Nrr$T)rð) ÚintÚ_rerÚhasattrÚNotImplementedErrorr%rÚ mpf_expintr$r›rž©rÚnÚzr…ÚroundingÚrealÚimagr‚r‚rƒÚ_gamma_upper_intÁs    zMPContext._gamma_upper_intcCsht|ƒ}|dkr | |¡St|dƒst‚|j\}}t ||j||¡\}}|dur-| |¡S|  ||f¡S)Nrr$) r(rr*r+r%rr,r$r›ržr-r‚r‚rƒÚ _expint_intÎs    zMPContext._expint_intcCstt|dƒr)z| tj|j|g|j¢RŽ¡WSty(|jr ‚|jtjf}Ynw|j }|  tj ||g|j¢RŽ¡S©Nr$) r*r›rÚ mpf_nthrootr$r%rrirÚ_mpc_ržÚ mpc_nthroot©rr!r.r‚r‚rƒÚ_nthrootÛs   ýzMPContext._nthrootcCsR|j\}}t|dƒr| t ||j||¡¡St|dƒr'| t ||j||¡¡SdS©Nr$r7) r%r*r›rÚ mpf_besseljnr$ržÚ mpc_besseljnr7)rr.r/r…r0r‚r‚rƒÚ_besseljçs   ÿzMPContext._besseljrcCs¤|j\}}t|dƒr)t|dƒr)zt |j|j||¡}| |¡WSty(Ynwt|dƒr5|jtjf}n|j}t|dƒrD|jtjf}n|j}|  t  ||||¡¡Sr5) r%r*rÚmpf_agmr$r›rrr7ržÚmpc_agm)rÚaÚbr…r0Úvr‚r‚rƒÚ_agmîs   ÿzMPContext._agmcCó| tjt|ƒg|j¢RŽ¡Sr )r›rÚ mpf_bernoullir(r%©rr.r‚r‚rƒruüózMPContext.bernoullicCrEr )r›rÚ mpf_zeta_intr(r%rGr‚r‚rƒÚ _zeta_intÿrHzMPContext._zeta_intcCs4| |¡}| |¡}| tj|j|jg|j¢RŽ¡Sr )r"r›rÚ mpf_atan2r$r%)rr&r!r‚r‚rƒrzs   zMPContext.atan2cCsX| |¡}t|ƒ}| |¡r| tj||jg|j¢RŽ¡S| tj ||j g|j¢RŽ¡Sr ) r"r(Ú _is_real_typer›rÚmpf_psir$r%ržÚmpc_psir7)rÚmr/r‚r‚rƒrys  z MPContext.psicKó®t|ƒ|jvr | |¡}| |¡\}}t|dƒr,t |j||¡\}}| |¡| |¡fSt|dƒrEt  |j ||¡\}}|  |¡|  |¡fS|j |fi|¤Ž|j |fi|¤ŽfSr;)Útypernr"Ú _parse_precr*rÚ mpf_cos_sinr$r›Ú mpc_cos_sinr7ržr¾r»©rr!Úkwargsr…r0ÚcÚsr‚r‚rƒÚcos_sinó   $zMPContext.cos_sincKrPr;)rQrnr"rRr*rÚmpf_cos_sin_pir$r›Úmpc_cos_sin_pir7ržr¾r»rUr‚r‚rƒÚ cospi_sinpirZzMPContext.cospi_sinpicCs| ¡}|j|_|S)zP Create a copy of the context, with the same working precision. )Ú __class__r…)rrAr‚r‚rƒÚclone)szMPContext.clonecCót|dƒs t|ƒtur dSdS)Nr7FT©r*rQÚcomplex©rr!r‚r‚rƒrL4ózMPContext._is_real_typecCr`)Nr7TFrarcr‚r‚rƒÚ_is_complex_type9rdzMPContext._is_complex_typecCsrt|dƒr |jtkSt|dƒrt|jvSt|tƒst|tjƒr!dS| |¡}t|dƒs0t|dƒr5|  |¡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Ú TypeErrorrcr‚r‚rƒrg>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)Úisinfrgrcr‚r‚rƒÚisfiniteZszMPContext.isfinitecCsœ|sdSt|dƒr|j\}}}}|o|dkSt|dƒr%|j o$| |j¡St|ƒtvr/|dkSt||jƒrF|j \}}|s>dS|dkoE|dkS| |  |¡¡S)z< Determine if *x* is a nonpositive integer. Tr$rr7r) r*r$r2Úisnpintr1rQr rfroÚ_mpq_r")rr!ÚsignÚmanr²ÚbcÚpÚqr‚r‚rƒrkts      zMPContext.isnpintcCsFdd|j d¡dd|j d¡dd|j d¡dg}d  |¡S) NzMpmath settings:z mp.prec = %séz [default: 53]z mp.dps = %sz [default: 15]z mp.trap_complex = %sz[default: False]Ú )r…ÚljustÚdpsriÚjoin)rÚlinesr‚r‚rƒÚ__str__ˆs ý zMPContext.__str__cCs t|jƒSr )r Ú_precr€r‚r‚rƒÚ _repr_digitss zMPContext._repr_digitscCs|jSr )Ú_dpsr€r‚r‚rƒÚ _str_digits”szMPContext._str_digitsFcót|‡fdd„d|ƒ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 r‚©rp©r.r‚rƒr‡¨óz%MPContext.extraprec..N©ÚPrecisionManager©rr.Únormalize_outputr‚r€rƒÚ extraprec˜szMPContext.extrapreccót|d‡fdd„|ƒS)z– This function is analogous to extraprec (see documentation) but changes the decimal precision instead of the number of bits. Ncr~r r‚©Údr€r‚rƒr‡¯rz$MPContext.extradps..r‚r„r‚r€rƒÚextradpsªózMPContext.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. cóˆSr r‚rr€r‚rƒr‡Àóz$MPContext.workprec..Nr‚r„r‚r€rƒÚworkprec±szMPContext.workpreccr‡)z• This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. NcrŒr r‚rˆr€r‚rƒr‡Çrz#MPContext.workdps..r‚r„r‚r€rƒÚworkdpsÂr‹zMPContext.workdpsNr‚cs‡‡‡‡‡fdd„}|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 cs2ˆj}ˆdur ˆ |¡}nˆ}z…|dˆ_z ˆ|i|¤Ž}Wn ˆy*ˆj}Ynw|d} |ˆ_z ˆ|i|¤Ž}Wn ˆyHˆj}Ynw||krNn9ˆ ||¡ˆ |¡}|| kr`n.ˆrltd||| fƒ|}||kryˆ d|¡‚|t|dƒ7}t||ƒ}q0W|ˆ_| SW|ˆ_| S|ˆ_w)Né érz)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergenceé)r…Ú_default_hyper_maxprecr¢ÚmagÚprintÚ NoConvergencer(Úmin)ÚargsrVr…Úmaxprec2Úv1Úprec2Úv2Úerr©ÚcatchrÚfÚmaxprecÚverboser‚rƒÚf_autoprec_wrapped sZ    ÿ  ÿ  ÿÿÿ ìó ÿz.MPContext.autoprec..f_autoprec_wrappedr‚)rr r¡rŸr¢r£r‚ržrƒÚautoprecÉsD%zMPContext.autoprecéc sÐt|tƒrdd ‡‡‡fdd„|Dƒ¡St|tƒr*dd ‡‡‡fdd„|Dƒ¡St|dƒr9t|jˆfiˆ¤ŽSt|dƒrLd t|jˆfiˆ¤Žd St|t ƒrUt |ƒSt|ˆj ƒrd|j ˆfiˆ¤ŽSt |ƒ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|ˆfiˆ¤ŽVqdSr ©Únstr©Ú.0rW©rrVr.r‚rƒÚ ]ó€"z!MPContext.nstr..z(%s)c3r¦r r§r©r«r‚rƒr¬_r­r$r7ú(ú))rfÚlistrvÚtupler*rr$r9r7rÚreprÚmatrixÚ__nstr__Ústr)rr!r.rVr‚r«rƒr¨4s (       zMPContext.nstrcCs¬|r7t|tƒr7d| ¡vr7| ¡ dd¡}t |¡}| d¡}|s#d}| d¡ d¡}| |  |¡|  |¡¡St |dƒrN|j \}}||krJ|  |¡St dƒ‚td t|ƒƒ‚) NrŸú ÚÚrerÚimÚ_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rfrÚlowerÚreplaceÚ get_complexÚmatchÚgroupÚrstriprlr"r*rºr›Ú ValueErrorrhr²)rr!Ústringsr¾r¸r¹rArBr‚r‚rƒÚ_convert_fallbackjs      zMPContext._convert_fallbackcOs|j|i|¤ŽSr )r")rr˜rVr‚r‚rƒÚ mpmathify|szMPContext.mpmathifycCsŽ|rD| d¡r dS|j\}}d|vr|d}d|vr-|d}||jkr%dSt|ƒ}||fSd|vr@|d}||jkr.éÚzeroprecr’)r*r$r7rsrÚmake_hyp_summatorr…rÆr“Ú enumerateÚZeroDivisionErrorÚ nint_distancer(ÚmaxÚabsrÁÚ _hypsum_msgÚdictÚvaluesrlrrQr±ržr›)!rrprqÚflagsÚcoeffsr/Úaccurate_smallrVÚkeyrCÚsummatorr…r¡r†ÚepsshiftÚmagnitude_checkÚmax_total_jumpÚirWÚokÚiiÚccr.r‰ÚwpÚmag_dictÚzvÚ have_complexÚ magnitudeÚcancelÚjumps_resolvedÚaccuraterÏr‚r‚rƒÚhypsumšs”       €  ÿ ÿ  þ    Ý%  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"r›rÚ mpf_shiftr$r9r‚r‚rƒÚldexpïs 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.r‚r‚rƒÚfrexps zMPContext.frexpcKs\| |¡\}}| |¡}t|dƒr| t|j||ƒ¡St|dƒr*| 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$r7ú2Arguments need to be mpf or mpc compatible numbers) rRr"r*r›r%r$ržr>r7rÁ)rr!rVr…r0r‚r‚rƒÚfnegs.   zMPContext.fnegc Kóø| |¡\}}| |¡}| |¡}z\t|dƒr;t|dƒr)| t|j|j||ƒ¡WSt|dƒr;| t|j|j||ƒ¡WSt|dƒrdt|dƒrR| t|j|j||ƒ¡WSt|dƒri| t |j|j||ƒ¡WSWt dƒ‚Wt dƒ‚t 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*r›r&r$ržrBr7rArÁÚ OverflowErrorÚ_exact_overflow_msg©rr!r&rVr…r0r‚r‚rƒÚfaddFs*8        üüþ ÿzMPContext.faddc Ksü| |¡\}}| |¡}| |¡}z^t|dƒr=t|dƒr)| t|j|j||ƒ¡WSt|dƒr=| t|jtf|j ||ƒ¡WSt|dƒrft|dƒrT| t |j |j||ƒ¡WSt|dƒrk| t|j |j ||ƒ¡WSWt dƒ‚Wt dƒ‚t 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*r›r'r$ržrCrr7rDrÁrõrör÷r‚r‚rƒÚfsubs*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*r›r(r$ržrFr7rErÁrõrör÷r‚r‚rƒÚfmulÒs*3        üüþ ÿzMPContext.fmulcKsÖ| |¡\}}|s tdƒ‚| |¡}| |¡}t|dƒr@t|dƒr-| t|j|j||ƒ¡St|dƒr@| t|jt f|j ||ƒ¡St|dƒrgt|dƒrV| t |j |j||ƒ¡St|dƒrg| 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ò) rRrÁr"r*r›r*r$ržrHrr7rIr÷r‚r‚rƒÚfdivs 1        zMPContext.fdivcCsøt|ƒ}|tvrt|ƒ|jfS|tjurD|j\}}t||ƒ\}}d||kr+|d7}n|s2||jfStt |||ƒƒt|ƒ}||fSt |dƒrP|j }|j} n;t |dƒrs|j \}} | \} } } }| rg| |} n$| t kro|j} ntdƒ‚| |¡}t |dƒs‚t |dƒr‡| |¡Stdƒ‚|\}}}}||}|dkržd}|}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 r’rr$r7zrequires a finite numberzrequires an mpf/mpcréÿÿÿÿ)rQr r(r¡r]rorlÚdivmodr7rÕr*r$r7rrÁr"rÓrhrÔ)rr!Útypxrprqr.Úrr‰r¸Úim_distr¹ÚisignÚimanÚiexpÚibcrmrnr²ror”Úre_distÚtr‚r‚rƒrÓYsn!                 €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') )r…rœ)rÚfactorsÚorigrCrpr‚r‚rƒÚfprod»s  ÿÿzMPContext.fprodcCs| t|jƒ¡S)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. )r›r5ryr€r‚r‚rƒÚrandÐszMPContext.randcs| ‡‡fdd„dˆˆf¡S)a Given Python integers `(p, q)`, returns a lazy ``mpf`` representing the fraction `p/q`. The value is updated with the precision. >>> from mpmath import * >>> mp.dps = 15 >>> a = fraction(1,100) >>> b = mpf(1)/100 >>> print(a); print(b) 0.01 0.01 >>> mp.dps = 30 >>> print(a); print(b) # a will be accurate 0.01 0.0100000000000000002081668171172 >>> mp.dps = 15 cstˆˆ||ƒSr )rr„©rprqr‚rƒr‡êsz$MPContext.fraction..z%s/%s)rm)rrprqr‚r rƒÚfractionØs ÿzMPContext.fractioncCót| |¡ƒSr ©rÕr"rcr‚r‚rƒÚabsminíózMPContext.absmincCr r rrcr‚r‚rƒÚabsmaxðrzMPContext.absmaxcCs,t|dƒr|j\}}| |¡| |¡gS|S)Nrº)r*rºr›)rr!rArBr‚r‚rƒÚ _as_pointsós  zMPContext._as_pointsrc slˆ |¡r t|dƒs t‚t|ƒ}ˆj}t |j|||||¡\}}‡fdd„|Dƒ}‡fdd„|Dƒ}||fS)Nr7cóg|]}ˆ |¡‘qSr‚©rž)rªr!r€r‚rƒÚ óz+MPContext._zetasum_fast..crr‚r)rªr&r€r‚rƒrr)Úisintr*r+r(ryrÚ mpc_zetasumr7) rrXrAr.Ú derivativesÚreflectr…ÚxsÚysr‚r€rƒÚ _zetasum_fast szMPContext._zetasum_fast)r©F)Nr‚F)r¥)T)8Ú__name__Ú __module__Ú __qualname__Ú__doc__rhrrr8r'r3r4r:r>rDrurJrzryrYr]r_rLrergrjrkrxÚpropertyrzr|r†rŠrŽrr¤r¨rÃrÄrRrörÖrírïrñrórørùrúrûrÓr r r rrrrr‚r‚r‚rƒre:sp!V              k6 U6JBEBbrec@s.eZdZd dd„Zdd„Zdd„Zdd „Zd S) rƒFcCs||_||_||_||_dSr )rÚprecfunÚdpsfunr…)Úselfrr$r%r…r‚r‚rƒrhs zPrecisionManager.__init__cst ˆ¡‡‡fdd„ƒ}|S)Ncs¤ˆjj}zHˆjrˆ ˆjj¡ˆj_n ˆ ˆjj¡ˆj_ˆjrAˆ|i|¤Ž}t|ƒtur9tdd„|DƒƒW|ˆj_S| W|ˆj_Sˆ|i|¤ŽW|ˆj_S|ˆj_w)NcSsg|]}| ‘qSr‚r‚)rªrAr‚r‚rƒr'sz8PrecisionManager.__call__..g..)rr…r$r%rur…rQr±)r˜rVrrC©r r&r‚rƒÚgs  ü þz$PrecisionManager.__call__..g)Ú functoolsÚwraps)r&r r(r‚r'rƒÚ__call__szPrecisionManager.__call__cCs<|jj|_|jr| |jj¡|j_dS| |jj¡|j_dSr )rr…Úorigpr$r%ru)r&r‚r‚rƒÚ __enter__.s zPrecisionManager.__enter__cCs|j|j_dSrf)r,rr…)r&Úexc_typeÚexc_valÚexc_tbr‚r‚rƒÚ__exit__4s zPrecisionManager.__exit__Nr)rr r!rhr+r-r1r‚r‚r‚rƒrƒs   rƒÚ__main__)wr"Ú __docformat__r)r¸Úctx_baserÚ libmp.backendrrr·rrr 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__ÚnewÚcompiler½Úsage.libs.mpmath.ext_mainr_rgÚlibsÚmpmathÚext_mainÚ _mpf_modulerar`rbrcrdrerƒrÚdoctestÚtestmodr‚r‚r‚rƒÚsD  þ^      d $ þ