B 'kº[Âã@sVdZdZddlZddlmZddlmZmZddlm 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;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m Z dd lm^Z^dd lm_Z_e`jaZbe cd ¡Zded krìdd lemfZgddlemhmimjZknddllmmZgddlmlZkddllmnZnmoZompZpGdd„degeƒZqGdd„dƒZresdkrRddltZtet u¡dS)z[ This module defines the mpf, mpc classes, and standard functions for operating with them. Z 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,jt,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¢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ÚrndrxrxryÚksz)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)³rgrhÚmake_mpfrÚonerÚzeroÚmake_mpcÚjrÚinfr Úninfr!Únanrir}rNr~rRrrSr€rQrrPr‚rTrƒrUr„rWr…rXr†rVr‡rOrˆrYr‰rZrŠZ_wrap_libmp_functionrZmpf_sqrtZmpc_sqrtZsqrtZmpf_cbrtZmpc_cbrtZcbrtZmpf_logZmpc_logZlnZmpf_atanZmpc_atanZatanZmpf_expZmpc_expÚexpZmpf_expjZmpc_expjZexpjZ mpf_expjpiZ mpc_expjpiZexpjpiZmpf_sinZmpc_sinÚsinZmpf_cosZmpc_cosÚcosZmpf_tanZmpc_tanZtanZmpf_sinhZmpc_sinhZsinhZmpf_coshZmpc_coshZcoshZmpf_tanhZmpc_tanhZtanhZmpf_asinZmpc_asinZasinZmpf_acosZmpc_acosZacosZ mpf_asinhZ mpc_asinhZasinhZ mpf_acoshZ mpc_acoshZacoshZ mpf_atanhZ mpc_atanhZatanhZ mpf_sin_piZ mpc_sin_pirvZ mpf_cos_piZ mpc_cos_piruZ mpf_floorZ mpc_floorZfloorZmpf_ceilZmpc_ceilZceilZmpf_nintZmpc_nintZnintZmpf_fracZmpc_fracZfracZ mpf_fibonacciZ mpc_fibonacciZfibZ fibonacciZ mpf_gammaZ mpc_gammaÚgammaZ mpf_rgammaZ mpc_rgammaZrgammaZ mpf_loggammaZ mpc_loggammaZloggammaZ mpf_factorialZ mpc_factorialZfacZ factorialZ mpf_gamma_oldZ mpc_gamma_oldZ gamma_oldZmpf_factorial_oldZmpc_factorial_oldZfac_oldZ factorial_oldZmpf_psi0Zmpc_psi0rtZ mpf_harmonicZ mpc_harmonicZharmonicZmpf_eiZmpc_eiZeiZmpf_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)rwrgrhr}rxrxryrm^s”      zMPContext.init_builtinscCs | |¡S)N)r7)rwÚxrzrxrxryr7¶szMPContext.to_fixedcCs2| |¡}| |¡}| tj|j|jf|jžŽ¡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‹rZ mpf_hypotÚ_mpf_Ú_prec_rounding)rwr™ÚyrxrxryÚhypot¹s  zMPContext.hypotcCsvt| |¡ƒ}|dkr | |¡St|dƒs.t‚|j\}}tj||j||dd\}}|dkrd|  |¡S|  ||f¡SdS)Nrr›T)r–) ÚintZ_rer—ÚhasattrÚNotImplementedErrorrœrÚ mpf_expintr›r‹rŽ)rwÚnÚzrzÚroundingÚrealÚimagrxrxryÚ_gamma_upper_intÁs    zMPContext._gamma_upper_intcCslt|ƒ}|dkr| |¡St|dƒs(t‚|j\}}t ||j||¡\}}|dkrZ| |¡S|  ||f¡SdS)Nrr›) rŸr—r r¡rœrr¢r›r‹rŽ)rwr£r¤rzr¥r¦r§rxrxryÚ _expint_intÎs    zMPContext._expint_intcCsrt|dƒrRy| tj|j|f|jžŽ¡Stk rN|jr>‚|jtjf}YqXXn|j }|  tj ||f|jžŽ¡S)Nr›) r r‹rZ mpf_nthrootr›rœrrfrÚ_mpc_rŽZ mpc_nthroot)rwr™r£rxrxryÚ_nthrootÛs zMPContext._nthrootcCsR|j\}}t|dƒr,| t ||j||¡¡St|dƒrN| t ||j||¡¡SdS)Nr›rª) rœr r‹rZ mpf_besseljnr›rŽZ mpc_besseljnrª)rwr£r¤rzr¥rxrxryÚ_besseljçs    zMPContext._besseljrcCs¤|j\}}t|dƒrRt|dƒrRyt |j|j||¡}| |¡Stk rPYnXt|dƒrj|jtjf}n|j}t|dƒrˆ|jtjf}n|j}|  t  ||||¡¡S)Nr›) rœr rZmpf_agmr›r‹rrrªrŽZmpc_agm)rwÚaÚbrzr¥ÚvrxrxryÚ_agmîs    zMPContext._agmcCs| tjt|ƒf|jžŽ¡S)N)r‹rZ mpf_bernoullirŸrœ)rwr£rxrxryroüszMPContext.bernoullicCs| tjt|ƒf|jžŽ¡S)N)r‹rZ mpf_zeta_intrŸrœ)rwr£rxrxryÚ _zeta_intÿszMPContext._zeta_intcCs2| |¡}| |¡}| tj|j|jf|jžŽ¡S)N)ršr‹rZ mpf_atan2r›rœ)rwrr™rxrxryrqs  zMPContext.atan2cCsX| |¡}t|ƒ}| |¡r8| tj||jf|jžŽ¡S| tj ||j f|jžŽ¡SdS)N) ršrŸÚ _is_real_typer‹rZmpf_psir›rœrŽZmpc_psirª)rwÚmr¤rxrxryrps   z MPContext.psicKsªt|ƒ|jkr| |¡}| |¡\}}t|dƒrXt |j||¡\}}| |¡| |¡fSt|dƒrŠt  |j ||¡\}}|  |¡|  |¡fS|j |f|Ž|j |f|ŽfSdS)Nr›rª)ÚtyperjršÚ _parse_precr rZ mpf_cos_sinr›r‹Z mpc_cos_sinrªrŽr•r”)rwr™Úkwargsrzr¥ÚcÚsrxrxryÚcos_sins   zMPContext.cos_sincKsªt|ƒ|jkr| |¡}| |¡\}}t|dƒrXt |j||¡\}}| |¡| |¡fSt|dƒrŠt  |j ||¡\}}|  |¡|  |¡fS|j |f|Ž|j |f|ŽfSdS)Nr›rª)r´rjršrµr rZmpf_cos_sin_pir›r‹Zmpc_cos_sin_pirªrŽr•r”)rwr™r¶rzr¥r·r¸rxrxryÚ cospi_sinpis   zMPContext.cospi_sinpicCs| ¡}|j|_|S)zP Create a copy of the context, with the same working precision. )Ú __class__rz)rwr­rxrxryÚclone)szMPContext.clonecCst|dƒst|ƒtkrdSdS)NrªFT)r r´Úcomplex)rwr™rxrxryr²4szMPContext._is_real_typecCst|dƒst|ƒtkrdSdS)NrªTF)r r´r½)rwr™rxrxryÚ_is_complex_type9szMPContext._is_complex_typecCsvt|dƒr|jtkSt|dƒr(t|jkSt|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\rkršÚisnanÚ TypeError)rwr™rxrxryrÀ>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)ZisinfrÀ)rwr™rxrxryÚisfiniteZszMPContext.isfinitecCsœ|sdSt|dƒr,|j\}}}}|o*|dkSt|dƒrJ|j oH| |j¡St|ƒtkr^|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¿rkÚ_mpq_rš)rwr™ÚsignÚmanr“ÚbcÚpÚqrxrxryrÃ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]Ú )rzÚljustÚdpsrfÚjoin)rwÚlinesrxrxryÚ__str__ˆs zMPContext.__str__cCs t|jƒS)N)r Ú_prec)rwrxrxryÚ _repr_digitsszMPContext._repr_digitscCs|jS)N)Z_dps)rwrxrxryÚ _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|ˆS)Nrx)rÈ)r£rxryr|¨sz%MPContext.extraprec..N)ÚPrecisionManager)rwr£Únormalize_outputrx)r£ryÚ 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|ˆS)Nrx)Úd)r£rxryr|¯sz$MPContext.extradps..)rÔ)rwr£rÕrx)r£ryÚ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ˆS)Nrx)rÈ)r£rxryr|Àsz$MPContext.workprec..N)rÔ)rwr£rÕrx)r£ryÚ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ˆS)Nrx)r×)r£rxryr|Çsz#MPContext.workdps..)rÔ)rwr£rÕrx)r£ryÚworkdpsÂszMPContext.workdpsNrxcs‡‡‡‡‡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}ˆdkrˆ |¡}nˆ}zð|dˆ_yˆ||Ž}Wnˆk rRˆj}YnX|d}x®|ˆ_yˆ||Ž}Wnˆk rŒˆj}YnX||kr˜Pˆ ||¡ˆ |¡}|| kr¼PˆrÔtd||| fƒ|}||krd|¡‚|t|dƒ7}t||ƒ}q^WWd|ˆ_X| S)Né éz)autoprec: target=%s, prec=%s, accuracy=%sz2autoprec: prec increased to %i without convergenceé)rzÚ_default_hyper_maxprecr’ÚmagÚprintZ NoConvergencerŸÚmin)Úargsr¶rzZmaxprec2Zv1Zprec2Zv2Úerr)ÚcatchrwÚfÚmaxprecÚverboserxryÚf_autoprec_wrapped sD     z.MPContext.autoprec..f_autoprec_wrappedrx)rwrårærärçrèrx)rärwrårærçryÚautoprecÉsD%zMPContext.autoprecéc sÄt|tƒr*dd ‡‡‡fdd„|Dƒ¡St|tƒrTdd ‡‡‡fdd„|Dƒ¡St|dƒrnt|jˆfˆŽSt|dƒrd t|jˆfˆŽd St|t ƒr¢t |ƒSt|ˆj ƒr¼|j ˆfˆŽ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|ˆfˆŽVqdS)N)Únstr)Ú.0r·)rwr¶r£rxryú ]sz!MPContext.nstr..z(%s)c3s|]}ˆj|ˆfˆŽVqdS)N)rë)rìr·)rwr¶r£rxryrí_sr›rªú(ú))r¿ÚlistrÎÚtupler rr›r8rªrÚreprZmatrixZ__nstr__Ústr)rwr™r£r¶rx)rwr¶r£ryrë4s(        zMPContext.nstrcCs°|rnt|tƒrnd| ¡krn| ¡ 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Úrstriprhršr rør‹Ú ValueErrorrÁrò)rwr™Zstringsrürör÷r­r®rxrxryÚ_convert_fallbackjs      zMPContext._convert_fallbackcOs |j||ŽS)N)rš)rwrâr¶rxrxryÚ mpmathify|szMPContext.mpmathifycCsˆ|r‚| d¡rdS|j\}}d|kr,|d}d|krT|d}||jkrJdSt|ƒ}n&d|krz|d}||jkrrdSt|ƒ}||fS|jS)NÚexact)rrår¥rzrÍ)ÚgetrœrrŸr)rwr¶rzr¥rÍrxrxryrµ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} ||jkrXt |¡d|j|<|j|} |j} | d| | ¡¡} d} d}i}d }xt |ƒD]ô\}}||d kr ||kr–|d kr–d }x.éÚzeroprecrÝ)r r›rªrnrZmake_hyp_summatorrzrrÞÚ enumerateÚZeroDivisionErrorÚ nint_distancerŸÚmaxÚabsrÿÚ _hypsum_msgÚdictÚvaluesrhrr´rñrŽr‹)!rwrÈrÉÚflagsZcoeffsr¤Zaccurate_smallr¶Úkeyr¯ZsummatorrzrærÖZepsshiftZmagnitude_checkZmax_total_jumpÚir·ÚokZiiZccr£r×ZwpZmag_dictZzvZ have_complexZ magnitudeZcancelZjumps_resolvedZaccurater rxrxryÚ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‹rZ mpf_shiftr›)rwr™r£rxrxryÚ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‹)rwr™rr£rxrxryÚ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ªz2Arguments need to be mpf or mpc compatible numbersN) rµršr r‹r$r›rŽr=rªrÿ)rwr™r¶rzr¥rxrxryÚfnegs.   zMPContext.fnegc Ksò| |¡\}}| |¡}| |¡}y t|dƒrrt|dƒrP| t|j|j||ƒ¡St|dƒrr| t|j|j||ƒ¡St|dƒrÀt|dƒrž| t|j|j||ƒ¡St|dƒrÀ| t |j|j||ƒ¡SWn"t t fk rät |j ƒ‚YnXt 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ªz2Arguments need to be mpf or mpc compatible numbersN) rµršr r‹r%r›rŽrArªr@rÿÚ OverflowErrorÚ_exact_overflow_msg)rwr™rr¶rzr¥rxrxryÚfaddFs"8        zMPContext.faddc Ksö| |¡\}}| |¡}| |¡}y¤t|dƒrvt|dƒrP| t|j|j||ƒ¡St|dƒrv| t|jtf|j ||ƒ¡St|dƒrÄt|dƒr¢| t |j |j||ƒ¡St|dƒrÄ| t|j |j ||ƒ¡SWn"t t fk rèt |j ƒ‚YnXt 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ªz2Arguments need to be mpf or mpc compatible numbersN)rµršr r‹r&r›rŽrBrrªrCrÿrr)rwr™rr¶rzr¥rxrxryÚfsubs"0        zMPContext.fsubc Ksò| |¡\}}| |¡}| |¡}y t|dƒrrt|dƒrP| t|j|j||ƒ¡St|dƒrr| t|j|j||ƒ¡St|dƒrÀt|dƒrž| t|j|j||ƒ¡St|dƒrÀ| t |j|j||ƒ¡SWn"t t fk rät |j ƒ‚YnXt 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ªz2Arguments need to be mpf or mpc compatible numbersN) rµršr r‹r'r›rŽrErªrDrÿrr)rwr™rr¶rzr¥rxrxryÚ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ªz2Arguments need to be mpf or mpc compatible numbersN) rµrÿršr r‹r)r›rŽrGrrªrH)rwr™rr¶rzr¥rxrxryÚfdivs 1        zMPContext.fdivcCs t|ƒ}|tkrt|ƒ|jfS|tjkrˆ|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 rÝrr›rªzrequires a finite numberzrequires an mpf/mpcréÿÿÿÿ)r´r rŸr‘r\rkrÄÚdivmodr6rr r›rªrrÿršrrÁr)rwr™ZtypxrÈrÉr£Úrr×röZim_distr÷ZisignZimanZiexpZibcrÅrÆr“rÇrßZre_distÚtrxrxryrYsl!                       zMPContext.nint_distancecCs6|j}z |j}x|D] }||9}qWWd||_X| 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') N)rzrŒ)rwZfactorsÚorigr¯rÈrxrxryÚ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‹r4rÑ)rwrxrxryÚ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ˆˆ||ƒS)N)r)rzr{)rÈrÉrxryr|êsz$MPContext.fraction..z%s/%s)ri)rwrÈrÉrx)rÈrÉryÚfractionØszMPContext.fractioncCst| |¡ƒS)N)rrš)rwr™rxrxryÚabsminíszMPContext.absmincCst| |¡ƒS)N)rrš)rwr™rxrxryÚabsmaxðszMPContext.absmaxcCs,t|dƒr(|j\}}| |¡| |¡gS|S)Nrø)r rør‹)rwr™r­r®rxrxryÚ _as_pointsós  zMPContext._as_pointsrc slˆ |¡rt|dƒst‚t|ƒ}ˆj}t |j|||||¡\}}‡fdd„|Dƒ}‡fdd„|Dƒ}||fS)Nrªcsg|]}ˆ |¡‘qSrx)rŽ)rìr™)rwrxryú sz+MPContext._zetasum_fast..csg|]}ˆ |¡‘qSrx)rŽ)rìr)rwrxryr.s)Zisintr r¡rŸrÑrZ mpc_zetasumrª) rwr¸r­r£Z derivativesZreflectrzZxsZysrx)rwryÚ _zetasum_fast szMPContext._zetasum_fast)r)F)F)F)F)NrxF)rê)T)8Ú__name__Ú __module__Ú __qualname__Ú__doc__rermr7ržr¨r©r«r¬r°ror±rqrpr¹rºr¼r²r¾rÀrÂrÃrÐÚpropertyrÒrÓrÖrØrÙrÚrérërrrµrrrrrrrr r!r"rr(r)r*r+r,r-r/rxrxrxryrc8sh!X              k 6 U6JBEBbrcc@s.eZdZd dd„Zdd„Zdd„Zdd „Zd S) rÔFcCs||_||_||_||_dS)N)rwÚprecfunÚdpsfunrÕ)Úselfrwr5r6rÕrxrxryreszPrecisionManager.__init__cs"‡‡fdd„}ˆj|_ˆj|_|S)Ncs†ˆjj}znˆjr$ˆ ˆjj¡ˆj_nˆ ˆjj¡ˆj_ˆjrjˆ||Ž}t|ƒtkrdtdd„|DƒƒS| Sˆ||ŽSWd|ˆj_XdS)NcSsg|] }| ‘qSrxrx)rìr­rxrxryr.&sz8PrecisionManager.__call__..g..)rwrzr5r6rÍrÕr´rñ)râr¶r'r¯)rår7rxryÚgs  z$PrecisionManager.__call__..g)r0r3)r7rår8rx)rår7ryÚ__call__szPrecisionManager.__call__cCs:|jj|_|jr$| |jj¡|j_n| |jj¡|j_dS)N)rwrzÚorigpr5r6rÍ)r7rxrxryÚ __enter__/s zPrecisionManager.__enter__cCs|j|j_dS)NF)r:rwrz)r7Úexc_typeZexc_valZexc_tbrxrxryÚ__exit__5s zPrecisionManager.__exit__N)F)r0r1r2rer9r;r=rxrxrxryrÔs rÔÚ__main__)vr3Z __docformat__röZctx_baserZ libmp.backendrrrõrrrr 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\ÚobjectÚ__new__ÚnewÚcompilerûZsage.libs.mpmath.ext_mainr]rdZlibsZmpmathZext_mainZ _mpf_moduler_r^r`rarbrcrÔr0ZdoctestZtestmodrxrxrxryÚs>  ÿ]       f%