a ›¬Z>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 lfmgZhddlfmimjmkZlnddlmmnZhddl mmZlddlmmoZompZpmqZqGdd„deheƒZrGdd„dƒZsetdkrZddluZueu v¡dS)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)ÚrationalzX^\(?(?P[\+\-]?\d*\.?\d*(e[\+\-]?\d+)?)??(?P[\+\-]?\d*\.?\d*(e[\+\-]?\d+)?j)?\)?$Zsage)Ú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„Zdod6d7„Zdpd8d9„Zdqd:d;„Z drd>d?„Z!dsdAdB„Z"dCdD„Z#dEdF„Z$dGdH„Z%dIZ&dJZ'dtdLdM„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„Z6djgd3fdkdl„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 ©ÚprecZrndr|r|r}Úmóz)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ÚmertensZ _sage_sqrtZ _sage_expZ_sage_lnZ _sage_cosZ _sage_sin)¬rjrkÚmake_mpfrÚonerÚzeroÚmake_mpcÚjr Úinfr!Úninfr"Únanrlr‚rOrƒrSr„rTr…rRr†rQr‡rUrˆrVr‰rXrŠrYr‹rWrŒrPrrZrŽr[rZ_wrap_libmp_functionrZmpf_sqrtZmpc_sqrtÚsqrtZmpf_cbrtZmpc_cbrtZcbrtZmpf_logZmpc_logÚlnZmpf_atanZmpc_atanÚatanZmpf_expZmpc_expÚexpZmpf_expjZmpc_expjZexpjZ mpf_expjpiZ mpc_expjpiZexpjpiZmpf_sinZmpc_sinÚsinZmpf_cosZmpc_cosÚcosZmpf_tanZmpc_tanÚtanZmpf_sinhZmpc_sinhÚsinhZmpf_coshZmpc_coshÚcoshZmpf_tanhZmpc_tanhÚtanhZmpf_asinZmpc_asinÚasinZmpf_acosZmpc_acosÚacosZ mpf_asinhZ mpc_asinhÚasinhZ mpf_acoshZ mpc_acoshÚacoshZ mpf_atanhZ mpc_atanhÚatanhZ mpf_sin_piZ mpc_sin_piryZ mpf_cos_piZ mpc_cos_pirxZ mpf_floorZ mpc_floorÚfloorZmpf_ceilZmpc_ceilÚceilZmpf_nintZmpc_nintZnintZmpf_fracZmpc_fracÚfracZ mpf_fibonacciZ mpc_fibonacciZfibZ fibonacciZ mpf_gammaZ mpc_gammaÚgammaZ mpf_rgammaZ mpc_rgammaZrgammaZ mpf_loggammaZ mpc_loggammaZloggammaZ mpf_factorialZ mpc_factorialZfacÚ factorialZmpf_psi0Zmpc_psi0rwZ mpf_harmonicZ mpc_harmonicZharmonicZmpf_eiZmpc_eiÚeiZmpf_e1Zmpc_e1Úe1Zmpf_ciZmpc_ciZ_ciZmpf_siZmpc_siZ_siZ mpf_ellipkZ mpc_ellipkZellipkZ mpf_ellipeZ mpc_ellipeZ_ellipeZmpf_agm1Zmpc_agm1Zagm1Zmpf_erfZ_erfZmpf_erfcZ_erfcZmpf_zetaZmpc_zetaZ_zetaZ mpf_altzetaZ mpc_altzetaZ_altzetaÚgetattr)r{rjrkr‚r|r|r}rp`s’      ÿzMPContext.init_builtinscCs | |¡S©N)r8)r{Úxrr|r|r}r8¶szMPContext.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.)ÚconvertrrZ mpf_hypotÚ_mpf_Ú_prec_rounding)r{r°Úyr|r|r}Úhypot¹s  zMPContext.hypotcCsvt| |¡ƒ}|dkr | |¡St|dƒs.t‚|j\}}tj||j||dd\}}|durd|  |¡S|  ||f¡SdS)Nrr²T)rª) ÚintÚ_rer­ÚhasattrÚNotImplementedErrorr³rÚ mpf_expintr²rr“©r{ÚnÚzrÚroundingÚrealÚimagr|r|r}Ú_gamma_upper_intÁs    zMPContext._gamma_upper_intcCslt|ƒ}|dkr| |¡St|dƒs(t‚|j\}}t ||j||¡\}}|durZ| |¡S|  ||f¡SdS)Nrr²) r¶r­r¸r¹r³rrºr²rr“r»r|r|r}Ú _expint_intÎs    zMPContext._expint_intcCsvt|dƒrTz | tj|j|g|j¢RŽ¡WStyP|jr@‚|jtjf}YqZ0n|j }|  tj ||g|j¢RŽ¡S©Nr²) r¸rrZ mpf_nthrootr²r³rrhrÚ_mpc_r“Z mpc_nthroot©r{r°r¼r|r|r}Ú_nthrootÛs   zMPContext._nthrootcCsR|j\}}t|dƒr,| t ||j||¡¡St|dƒrN| t ||j||¡¡SdS©Nr²rÄ) r³r¸rrZ mpf_besseljnr²r“Z mpc_besseljnrÄ)r{r¼r½rr¾r|r|r}Ú_besseljçs    zMPContext._besseljrcCs¤|j\}}t|dƒrRt|dƒrRz t |j|j||¡}| |¡WStyPYn0t|dƒrj|jtjf}n|j}t|dƒrˆ|jtjf}n|j}|  t  ||||¡¡SrÃ) r³r¸rZmpf_agmr²rrrrÄr“Zmpc_agm)r{ÚaÚbrr¾Úvr|r|r}Ú_agmîs   zMPContext._agmcCs| tjt|ƒg|j¢RŽ¡Sr¯)rrZ mpf_bernoullir¶r³©r{r¼r|r|r}rrüszMPContext.bernoullicCs| tjt|ƒg|j¢RŽ¡Sr¯)rrZ mpf_zeta_intr¶r³rÍr|r|r}Ú _zeta_intÿszMPContext._zeta_intcCs4| |¡}| |¡}| tj|j|jg|j¢RŽ¡Sr¯)r±rrZ mpf_atan2r²r³)r{r´r°r|r|r}rts  zMPContext.atan2cCs\| |¡}t|ƒ}| |¡r:| tj||jg|j¢RŽ¡S| tj ||j g|j¢RŽ¡SdSr¯) r±r¶Ú _is_real_typerrZmpf_psir²r³r“Zmpc_psirÄ)r{Úmr½r|r|r}rss   z MPContext.psicKs²t|ƒ|jvr| |¡}| |¡\}}t|dƒrXt |j||¡\}}| |¡| |¡fSt|dƒrŠt  |j ||¡\}}|  |¡|  |¡fS|j |fi|¤Ž|j |fi|¤ŽfSdSrÇ)Útypermr±Ú _parse_precr¸rZ mpf_cos_sinr²rZ mpc_cos_sinrÄr“rrœ©r{r°Úkwargsrr¾ÚcÚsr|r|r}Úcos_sins   zMPContext.cos_sincKs²t|ƒ|jvr| |¡}| |¡\}}t|dƒrXt |j||¡\}}| |¡| |¡fSt|dƒrŠt  |j ||¡\}}|  |¡|  |¡fS|j |fi|¤Ž|j |fi|¤ŽfSdSrÇ)rÑrmr±rÒr¸rZmpf_cos_sin_pir²rZmpc_cos_sin_pirÄr“rrœrÓr|r|r}Ú cospi_sinpis   zMPContext.cospi_sinpicCs| ¡}|j|_|S)zP Create a copy of the context, with the same working precision. )Ú __class__r)r{rÉr|r|r}Úclone)szMPContext.clonecCst|dƒst|ƒturdSdS)NrÄFT©r¸rÑÚcomplex©r{r°r|r|r}rÏ4szMPContext._is_real_typecCst|dƒst|ƒturdSdS)NrÄTFrÛrÝr|r|r}Ú_is_complex_type9szMPContext._is_complex_typecCsvt|dƒr|jtkSt|dƒr(t|jvSt|tƒs>t|tjƒrBdS| |¡}t|dƒs`t|dƒrj|  |¡St dƒ‚dS)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²rÄFzisnan() needs a number as inputN) r¸r²r"rÄÚ isinstancer r]rnr±ÚisnanÚ TypeErrorrÝr|r|r}rà>s      zMPContext.isnancCs| |¡s| |¡rdSdS)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)ÚisinfràrÝr|r|r}ÚisfiniteZszMPContext.isfinitecCsœ|sdSt|dƒr,|j\}}}}|o*|dkSt|dƒrJ|j oH| |j¡St|ƒtvr^|dkSt||jƒrŒ|j \}}|s|dS|dkoŠ|dkS| |  |¡¡S)z< Determine if *x* is a nonpositive integer. Tr²rrÄr) r¸r²rÀÚisnpintr¿rÑr rßrnÚ_mpq_r±)r{r°ÚsignÚmanr›ÚbcÚpÚqr|r|r}räts      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ÚdpsrhÚjoin)r{Úlinesr|r|r}Ú__str__ˆs ýzMPContext.__str__cCs t|jƒSr¯)r Ú_precrzr|r|r}Ú _repr_digitsszMPContext._repr_digitscCs|jSr¯)Z_dpsrzr|r|r}Ú _str_digits”szMPContext._str_digitsFcst|‡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. cs|ˆSr¯r|©ré©r¼r|r}r€¨rz%MPContext.extraprec..N©ÚPrecisionManager©r{r¼Únormalize_outputr|rör}Ú extraprec˜szMPContext.extrapreccst|d‡fdd„|ƒS)z– This function is analogous to extraprec (see documentation) but changes the decimal precision instead of the number of bits. Ncs|ˆSr¯r|©Údrör|r}r€¯rz$MPContext.extradps..r÷rùr|rör}ÚextradpsªszMPContext.extradpscst|‡fdd„d|ƒS)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. csˆSr¯r|rõrör|r}r€Àrz$MPContext.workprec..Nr÷rùr|rör}Úworkprec±szMPContext.workpreccst|d‡fdd„|ƒS)z• This function is analogous to workprec (see documentation) but changes the decimal precision instead of the number of bits. NcsˆSr¯r|rürör|r}r€Çrz#MPContext.workdps..r÷rùr|rör}ÚworkdpsÂszMPContext.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 cs(ˆj}ˆdurˆ |¡}nˆ}zú|dˆ_zˆ|i|¤Ž}WnˆyTˆj}Yn0|d}|ˆ_zˆ|i|¤Ž}WnˆyŽˆj}Yn0||krœqˆ ||¡ˆ |¡}|| krÂqˆrÚtd||| fƒ|}||krôˆ d|¡‚|t|dƒ7}t||ƒ}q^W|ˆ_n|ˆ_0| S)Né éz)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergenceé)rÚ_default_hyper_maxprecr—ÚmagÚprintZ NoConvergencer¶Úmin)ÚargsrÔrZmaxprec2Úv1Zprec2Úv2Úerr©Úcatchr{ÚfÚmaxprecÚverboser|r}Úf_autoprec_wrapped sH        ÿÿÿz.MPContext.autoprec..f_autoprec_wrappedr|)r{rrr rrr|r r}ÚautoprecÉsD%zMPContext.autoprecéc sÐt|tƒr*dd ‡‡‡fdd„|Dƒ¡St|tƒrTdd ‡‡‡fdd„|Dƒ¡St|dƒrrt|jˆfiˆ¤ŽSt|dƒr˜d t|jˆfiˆ¤Žd St|t ƒrªt |ƒSt|ˆj ƒrÈ|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, c3s"|]}ˆj|ˆfiˆ¤ŽVqdSr¯©Únstr©Ú.0rÕ©r{rÔr¼r|r}Ú ]rz!MPContext.nstr..z(%s)c3s"|]}ˆj|ˆfiˆ¤ŽVqdSr¯rrrr|r}r_rr²rÄú(ú))rßÚlistrïÚtupler¸rr²r9rÄrÚreprZmatrixZ__nstr__Ústr)r{r°r¼rÔr|rr}r4s(        zMPContext.nstrcCs°|rnt|tƒrnd| ¡vrn| ¡ dd¡}t |¡}| d¡}|sFd}| d¡ d¡}| |  |¡|  |¡¡St |dƒrœ|j \}}||kr”|  |¡St dƒ‚td t|ƒƒ‚dS) Nr”ú ÚÚrerÚimÚ_mpi_z,can only create mpf from zero-width intervalzcannot create mpf from )rßrÚlowerÚreplaceÚ get_complexÚmatchÚgroupÚrstriprkr±r¸r$rÚ ValueErrorrár)r{r°Ústringsr(r"r#rÉrÊr|r|r}Ú_convert_fallbackjs      zMPContext._convert_fallbackcOs|j|i|¤ŽSr¯)r±)r{rrÔr|r|r}Ú mpmathify|szMPContext.mpmathifycCsˆ|r‚| d¡rdS|j\}}d|vr,|d}d|vrT|d}||jkrJdSt|ƒ}n&d|vrz|d}||jkrrdSt|ƒ}||fS|jS)NÚexact)rrr¾rrî)Úgetr³r•r¶r)r{rÔrr¾rîr|r|r}rÒs$     zMPContext._parse_precz'the exact result does not fit in memoryzœ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.Tc!KsÖt|dƒr|||df}|j} nt|dƒr:|||df}|j} ||jvrXt |¡d|j|<|j|} |j} | d| | ¡¡} d} d}i}d }t |ƒD]ð\}}||d kr||kr’|d kr’d }t |d|…ƒD](\}}||d krÌ|d krÌ||krÌd }qÌ|s’t d ƒ‚q’|  |¡\}}t |ƒ }| }||krv|d krv|dkrv||vr\|||7<n|||<t | || dƒ} |t|ƒ7}q’| | kr¤t|j| | | fƒ‚| | }|rÆtdd„|Dƒƒ}ni}| || | |||fi|¤Ž\}}}| }d }| |kr,| ¡D]$}|dus|| krd }q,q|| ddkpB| }|rˆ|rTq¤| d¡} | durˆ|| krˆ|r‚| d ¡S|jS| d9} |d7}| d7} q„t|ƒturÎ|rÂ| |¡S| |¡Sn|SdS)Nr²ÚRrÄÚCrré2érÚZFTzpole in hypergeometric serieséé<css|]}|dfVqdSr¯r|)rr¼r|r|r}rÇrz#MPContext.hypsum..éÚzeroprecr)r¸r²rÄrqrZmake_hyp_summatorrr0rÚ enumerateÚZeroDivisionErrorÚ nint_distancer¶ÚmaxÚabsr+Ú _hypsum_msgÚdictÚvaluesrkr’rÑrr“r)!r{rérêÚflagsZcoeffsr½Zaccurate_smallrÔÚkeyrËZsummatorrrrûZepsshiftZmagnitude_checkZmax_total_jumpÚirÕÚokÚiiÚccr¼rýZwpZmag_dictZzvZ have_complexZ magnitudeÚcancelZjumps_resolvedZaccurater9r|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±rrZ mpf_shiftr²rÅr|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±rZ mpf_frexpr²r)r{r°r´r¼r|r|r}Úfrexps zMPContext.frexpcKs`| |¡\}}| |¡}t|dƒr6| t|j||ƒ¡St|dƒrT| t|j||ƒ¡St dƒ‚dS)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²rÄú2Arguments need to be mpf or mpc compatible numbersN) rÒr±r¸rr%r²r“r>rÄr+)r{r°rÔrr¾r|r|r}Úfnegs.   zMPContext.fnegc Ksø| |¡\}}| |¡}| |¡}z¨t|dƒrvt|dƒrR| t|j|j||ƒ¡WSt|dƒrv| t|j|j||ƒ¡WSt|dƒrÈt|dƒr¤| t|j|j||ƒ¡WSt|dƒrÈ| t |j|j||ƒ¡WSWn t t fyêt |j ƒ‚Yn0t dƒ‚dS)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²rÄrLN) rÒr±r¸rr&r²r“rBrÄrAr+Ú OverflowErrorÚ_exact_overflow_msg©r{r°r´rÔrr¾r|r|r}ÚfaddFs"8        zMPContext.faddc Ksü| |¡\}}| |¡}| |¡}z¬t|dƒrzt|dƒrR| t|j|j||ƒ¡WSt|dƒrz| t|jtf|j ||ƒ¡WSt|dƒrÌt|dƒr¨| t |j |j||ƒ¡WSt|dƒrÌ| t|j |j ||ƒ¡WSWn t t fyît |j ƒ‚Yn0t dƒ‚dS)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²rÄrLN)rÒr±r¸rr'r²r“rCrrÄrDr+rNrOrPr|r|r}Úfsubs"0        zMPContext.fsubc Ksø| |¡\}}| |¡}| |¡}z¨t|dƒrvt|dƒrR| t|j|j||ƒ¡WSt|dƒrv| t|j|j||ƒ¡WSt|dƒrÈt|dƒr¤| t|j|j||ƒ¡WSt|dƒrÈ| t |j|j||ƒ¡WSWn t t fyêt |j ƒ‚Yn0t dƒ‚dS)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²rÄrLN) rÒr±r¸rr(r²r“rFrÄrEr+rNrOrPr|r|r}ÚfmulÒs"3        zMPContext.fmulcKsÚ| |¡\}}|stdƒ‚| |¡}| |¡}t|dƒr€t|dƒrZ| t|j|j||ƒ¡St|dƒr€| t|jt f|j ||ƒ¡St|dƒrÎt|dƒr¬| t |j |j||ƒ¡St|dƒrÎ| t|j |j ||ƒ¡Stdƒ‚dS)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²rÄrLN) rÒr+r±r¸rr*r²r“rHrrÄrIrPr|r|r}Úfdivs 1        zMPContext.fdivcCs t|ƒ}|tvrt|ƒ|jfS|tjurˆ|j\}}t||ƒ\}}d||krV|d7}n|sd||jfStt |||ƒƒt|ƒ}||fSt |dƒr |j }|j} n|t |dƒrè|j \}} | \} } } }| rÎ| |} n| t krÞ|j} ntdƒ‚n4| |¡}t |dƒs t |dƒr| |¡Stdƒ‚|\}}}}||}|dkrDd}|}nº|rà|dkrd||>}|j}nn|dkr€|d?d}d}nR| d}||?}|d@r²|d7}||>|}n |||>8}|d?}|t|ƒ}|rþ| }n|t krö|j}d}ntdƒ‚|t|| ƒfS) aº Return `(n,d)` where `n` is the nearest integer to `x` and `d` is an estimate of `\log_2(|x-n|)`. If `d < 0`, `-d` gives the precision (measured in bits) lost to cancellation when computing `x-n`. >>> from mpmath import * >>> n, d = nint_distance(5) >>> print(n); print(d) 5 -inf >>> n, d = nint_distance(mpf(5)) >>> print(n); print(d) 5 -inf >>> n, d = nint_distance(mpf(5.00000001)) >>> print(n); print(d) 5 -26 >>> n, d = nint_distance(mpf(4.99999999)) >>> print(n); print(d) 5 -26 >>> n, d = nint_distance(mpc(5,10)) >>> print(n); print(d) 5 4 >>> n, d = nint_distance(mpc(5,0.000001)) >>> print(n); print(d) 5 -19 rrr²rÄzrequires a finite numberzrequires an mpf/mpcréÿÿÿÿ)rÑr r¶r–r]rnråÚdivmodr7r>r¸r²rÄrr+r±r<rár=)r{r°Ztypxrérêr¼Úrrýr"Zim_distr#ZisignZimanZiexpZibcrærçr›rèrZre_distÚtr|r|r}r<Ysl!                       zMPContext.nint_distancecCs8|j}z"|j}|D] }||9}qW||_n||_0| S)aT Calculates a product containing a finite number of factors (for infinite products, see :func:`~mpmath.nprod`). The factors will be converted to mpmath numbers. >>> from mpmath import * >>> mp.dps = 15; mp.pretty = False >>> fprod([1, 2, 0.5, 7]) mpf('7.0') )rr‘)r{ZfactorsÚorigrËrér|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. )rr5ròrzr|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~©rérêr|r}r€êrz$MPContext.fraction..z%s/%s)rl)r{rérêr|r\r}ÚfractionØs ÿzMPContext.fractioncCst| |¡ƒSr¯©r>r±rÝr|r|r}ÚabsminíszMPContext.absmincCst| |¡ƒSr¯r^rÝr|r|r}ÚabsmaxðszMPContext.absmaxcCs,t|dƒr(|j\}}| |¡| |¡gS|S)Nr$)r¸r$r)r{r°rÉrÊr|r|r}Ú _as_pointsós  zMPContext._as_pointsrc slˆ |¡rt|dƒst‚t|ƒ}ˆj}t |j|||||¡\}}‡fdd„|Dƒ}‡fdd„|Dƒ}||fS)NrÄcsg|]}ˆ |¡‘qSr|©r“)rr°rzr|r}Ú rz+MPContext._zetasum_fast..csg|]}ˆ |¡‘qSr|rb)rr´rzr|r}rcr)Zisintr¸r¹r¶ròrZ mpc_zetasumrÄ) r{rÖrÉr¼Z derivativesZreflectrÚxsZysr|rzr}Ú _zetasum_fast szMPContext._zetasum_fast)r)F)F)F)F)Nr|F)r)T)8Ú__name__Ú __module__Ú __qualname__Ú__doc__rgrpr8rµrÁrÂrÆrÈrÌrrrÎrtrsr×rØrÚrÏrÞràrãrärñÚpropertyrórôrûrþrÿrrrr-r.rÒrOr?rIrJrKrMrQrRrSrTr<rZr[r]r_r`rarer|r|r|r}rd:sl!V              k 6 U6JBEBbrdc@s.eZdZd dd„Zdd„Zdd„Zdd „Zd S) røFcCs||_||_||_||_dSr¯)r{ÚprecfunÚdpsfunrú)Úselfr{rkrlrúr|r|r}rgszPrecisionManager.__init__cst ˆ¡‡‡fdd„ƒ}|S)Ncs´ˆjj}zœˆjr$ˆ ˆjj¡ˆj_nˆ ˆjj¡ˆj_ˆjr‚ˆ|i|¤Ž}t|ƒturrtdd„|DƒƒW|ˆj_S| W|ˆj_Sˆ|i|¤ŽW|ˆj_SW|ˆj_n |ˆj_0dS)NcSsg|] }| ‘qSr|r|)rrÉr|r|r}rc'rz8PrecisionManager.__call__..g..)r{rrkrlrîrúrÑr)rrÔrYrË©rrmr|r}Úgs$ ûüþz$PrecisionManager.__call__..g)Ú functoolsÚwraps)rmrror|rnr}Ú__call__szPrecisionManager.__call__cCs:|jj|_|jr$| |jj¡|j_n| |jj¡|j_dSr¯)r{rÚorigprkrlrî)rmr|r|r}Ú __enter__.s zPrecisionManager.__enter__cCs|j|j_dSre)rsr{r)rmÚexc_typeÚexc_valÚexc_tbr|r|r}Ú__exit__4s zPrecisionManager.__exit__N)F)rfrgrhrgrrrtrxr|r|r|r}røs røÚ__main__)wriZ __docformat__rpr"Zctx_baserZ 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'Zsage.libs.mpmath.ext_mainr^rfZlibsZmpmathZext_mainZ _mpf_moduler`r_rarbrcrdrørfÚdoctestÚtestmodr|r|r|r}Ús@  ÿ]       d$