~9\c@ sdZddlmZmZddlZddljZddlmZm Z m Z m Z m Z m Z mZmZmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZm 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/m0Z0ddlm1Z2ddl3m4Z4dd l5m6Z6dd l7m8Z8m9Z9dd l:m;Z;d d l<m=Z=m>Z>d dl?m?Z?d dl@mAZAddlBmCZCejDddZEe.ZFdZ1eGeZHeGe ZIdZJdeKfdYZLdZMeNdZOd dZPeNdZQdZRdZSdZTdZUdZVd ZWd!ZXd"ZYd#ZZeNd$Z[d%Z\d&Z]d'Z^d(Z_d)Z`d*Zad+Zbd,Zcd-Zdd.Zed/Zfd0Zgd1Zhd2Zid3Zjd4Zkd5Zld6Zmd7Znd8Zodaqd9Zrd:Zsd;etfd<YZud=d>ZvdS(?s^ Adaptive numerical evaluation of SymPy expressions, using mpmath for mathematical functions. i(tprint_functiontdivisionN( tmake_mpctmake_mpftmptmpctmpftnsumtquadtstquadosctworkprec(tinf(tfrom_intt from_man_expt from_rationaltfhalftfnantfnonetfonetfzerotmpf_abstmpf_addtmpf_atant mpf_atan2tmpf_cmptmpf_costmpf_etmpf_exptmpf_logtmpf_lttmpf_multmpf_negtmpf_pitmpf_powt mpf_pow_intt mpf_shifttmpf_sintmpf_sqrtt normalizet round_nearesttto_inttto_str(tbitcount(tMPZ(t _infs_nan(t dps_to_prect prec_to_dps(t mpf_bernoullii(t SYMPY_INTStrange(tsympify(tS(t is_sequencei icC sttt|S(s8Return smallest integer, b, such that |n|/2**b < 1. (tmpmath_bitcounttabstint(tn((s/lib/python2.7/site-packages/sympy/core/evalf.pyR*"siMtPrecisionExhaustedcB seZRS((t__name__t __module__(((s/lib/python2.7/site-packages/sympy/core/evalf.pyR91scC s'| s|tkrtS|d|dS(sDFast approximation of log2(x) for an mpf value tuple x. Notes: Calculated as exponent + width of mantissa. This is an approximation for two reasons: 1) it gives the ceil(log2(abs(x))) value and 2) it is too high by 1 in the case that x is an exact power of 2. Although this is easy to remedy by testing to see if the odd mpf mantissa is 1 (indicating that one was dealing with an exact power of 2) that would decrease the speed and is not necessary as this is only being used as an approximation for the number of bits in x. The correct return value could be written as "x[2] + (x[3] if x[1] != 1 else 0)". Since mpf tuples always have an odd mantissa, no check is done to see if the mantissa is a multiple of 2 (in which case the result would be too large by 1). Examples ======== >>> from sympy import log >>> from sympy.core.evalf import fastlog, bitcount >>> s, m, e = 0, 5, 1 >>> bc = bitcount(m) >>> n = [1, -1][s]*m*2**e >>> n, (log(n)/log(2)).evalf(2), fastlog((s, m, e, bc)) (10, 3.3, 4) ii(Rt MINUS_INF(tx((s/lib/python2.7/site-packages/sympy/core/evalf.pytfastlogQscC s[|j\}}|s,|r(||fSdS|j\}}|tjkrW||fSdS(sReturn a and b if v matches a + I*b where b is not zero and a and b are Numbers, else None. If `or_real` is True then 0 will be returned for `b` if `v` is a real number. >>> from sympy.core.evalf import pure_complex >>> from sympy import sqrt, I, S >>> a, b, surd = S(2), S(3), sqrt(2) >>> pure_complex(a) >>> pure_complex(a, or_real=True) (2, 0) >>> pure_complex(surd) >>> pure_complex(a + b*I) (2, 3) >>> pure_complex(I) (0, 1) N(t as_coeff_Addt as_coeff_MulR3t ImaginaryUnit(tvtor_realthtttcti((s/lib/python2.7/site-packages/sympy/core/evalf.pyt pure_complexrs cC st|tkrMt|dkrMt|dtrM|ddf|dSt|tr|d krwtdntt |d}}|dkrdnd}|gf|d}||fStddS( slReturn an mpf representing a power of two with magnitude ``mag`` and -1 for precision. Or, if ``mag`` is a scaled_zero tuple, then just remove the sign from within the list that it was initially wrapped in. Examples ======== >>> from sympy.core.evalf import scaled_zero >>> from sympy import Float >>> z, p = scaled_zero(100) >>> z, p (([0], 1, 100, 1), -1) >>> ok = scaled_zero(z) >>> ok (0, 1, 100, 1) >>> Float(ok) 1.26765060022823e+30 >>> Float(ok, p) 0.e+30 >>> ok, p = scaled_zero(100, -1) >>> Float(scaled_zero(ok), p) -0.e+30 itscalediiissign must be +/-1s-scaled zero expects int or scaled_zero tuple.N(ii( ttypettupletlentiszerotTruet isinstanceR0t ValueErrorR#R(tmagtsigntrvtpts((s/lib/python2.7/site-packages/sympy/core/evalf.pyt scaled_zeros6  cC s]|s!| p |d o |d S|o\t|dtko\|d|dkoZdkSS(Niii(RJtlist(RRI((s/lib/python2.7/site-packages/sympy/core/evalf.pyRMsc C sw|\}}}}|s&|s"tS|S|s0|St|}t|}t||||}|t||}| S(s Returns relative accuracy of a complex number with given accuracies for the real and imaginary parts. The relative accuracy is defined in the complex norm sense as ||z|+|error|| / |z| where error is equal to (real absolute error) + (imag absolute error)*i. The full expression for the (logarithmic) error can be approximated easily by using the max norm to approximate the complex norm. In the worst case (re and im equal), this is wrong by a factor sqrt(2), or by log2(sqrt(2)) = 0.5 bit. (tINFR>tmax( tresulttretimtre_acctim_acctre_sizetim_sizetabsolute_errortrelative_error((s/lib/python2.7/site-packages/sympy/core/evalf.pytcomplex_accuracys   c C st||d|\}}}}|sI||||f\}}}}n|r|jrttt||d|d|\}}} }|d| dfSd|krtj||f|d|dfSt|d|dfSn |rt|d|dfSdSdS(Nitsubs(NNNN(tevalft is_numberR6tNtNonetlibmptmpc_absR( texprtprectoptionsR[R\R]R^tabs_exprt_tacc((s/lib/python2.7/site-packages/sympy/core/evalf.pytget_abss"!  "c C s|}d}xt|||}||dd\}}| s^||ks^|d |krn|d|dfS|tdd|7}|d7}qWdS(s/no = 0 for real part, no = 1 for imaginary partiNiii(ReRhRY( RktnoRlRmR RGtrestvaluetaccuracy((s/lib/python2.7/site-packages/sympy/core/evalf.pytget_complex_parts$cC st|jd||S(Ni(Rqtargs(RkRlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_absscC st|jdd||S(Ni(RvRw(RkRlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pytevalf_rescC st|jdd||S(Nii(RvRw(RkRlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pytevalf_imscC s|tkr'|tkr'tdn8|tkrCd|d|fS|tkr_|d|dfSt|}t|}||kr|}|t|| d}n|}|t|| d}||||fS(Ns&got complex zero with unknown accuracyi(RRPRhR>tmin(R[R\Rltsize_retsize_imR]R^((s/lib/python2.7/site-packages/sympy/core/evalf.pytfinalize_complexs     cC s|\}}}}|rJ|tkrJt|| dkrJd\}}n|r|tkrt|| dkrd\}}n|r|rt|t|}|dkr||| dkrd\}}n|dkr|||dkrd\}}qn||||fS(s. Chop off tiny real or complex parts. iiN(NN(NN(NN(NN(R,R>Rh(RtRlR[R\R]R^tdelta((s/lib/python2.7/site-packages/sympy/core/evalf.pyt chop_partss)) ! cC s/t|}||kr+td|ndS(NsFailed to distinguish the expression: %s from zero. Try simplifying the input, using chop=True, or providing a higher maxn for evalf(RcR9(RkRZRlta((s/lib/python2.7/site-packages/sympy/core/evalf.pyt check_target)s  c sddlm}m}d}t||\}}} } |rl|rltt|| t|| } n6|rt|| } n|rt|| } ndSd} | | kr| || t|\}}} } n|fd} d \}}}}|r;| ||dt|\}}n|re| ||dt|\}}n|rtt |pzt tt |pt fS||||fS( s With no = 1, computes ceiling(expr) With no = -1, computes floor(expr) Note: this function either gives the exact result or signals failure. i(R[R\ii c sddlm}|\}}}}|dk}tt|t}|rt||d\} } } } | sxtt|  d} | krt|| \} } } } | st| }|\}}}}|dk}tt|t}qn|sjdt }|rt }ddl m }x|j D]}y||dt Wq@tk ry0g|jD]}||dt ^qzw@Wqttfk rt }PqXq@Xq@W|r|j|}qn||| d t }t|d\}}}}y t||d|dfd Wn/tk rc|jdsZtnt}nX|tt|pyttk7}nt|}|tfS( Ni(tAddii iRd(tas_inttstricttevaluatei(tsympy.core.addRR7R(trndRetAssertionErrorR>tgettFalseRNtsympy.core.compatibilityRtvaluesRPt as_real_imagtAttributeErrorRdRRhR9tequalsRRR RX(tre_imtnexprRR8RFRTtbtis_inttninttiretiimtire_acctiim_acctsizeRUtdoitRRBRGR=Rotx_acc(RrRmRl(s/lib/python2.7/site-packages/sympy/core/evalf.pyt calc_partUsZ      )     , RN(NNNN(NNNN( t$sympy.functions.elementary.complexesR[R\ReRYR>RhRR7R(R(RkRrRmt return_intsR[R\t assumed_sizeRRRRtgaptmarginRtre_tim_R]R^((RrRmRls/lib/python2.7/site-packages/sympy/core/evalf.pytget_integer_part1s2 & 8$$.cC st|jdd|S(Nii(RRw(RkRlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_ceilingscC st|jdd|S(Nii(RRw(RkRlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_floorscC s~g|D]}t|ds|^q}|s3d St|dkrM|dSg}ddlm}xL|D]D}|j|dd}|tjks|jrj|j |qjqjW|rddl m }t |||di}|d|dfSd|} ddt } } } x|D]\} }| \}}}}|rI| }nt| |||} || }|| kr|| kr| s|tt| | kr|} |} q | ||>7} q| }||| kr| s ||} } q q| |>|} |} qW| st| S| dkr9d}| } nd}t| }| || }t|| | ||t|f}|S( s% Helper for evalf_add. Adds a list of (mpfval, accuracy) terms. Returns ------- - None, None if there are no non-zero terms; - terms[0] if there is only 1 term; - scaled_zero if the sum of the terms produces a zero by cancellation e.g. mpfs representing 1 and -1 would produce a scaled zero which need special handling since they are not actually zero and they are purposely malformed to ensure that they can't be used in anything but accuracy calculations; - a tuple that is scaled to target_prec that corresponds to the sum of the terms. The returned mpf tuple will be normalized to target_prec; the input prec is used to define the working precision. XXX explain why this is needed and why one can't just loop using mpf_add iii(tFloat(RiiN(NN(RMRhRLtsympy.core.numbersRt_newR3tNaNt is_infinitetappendRRReR<RYR*R6RVR&R(ttermsRlt target_precREtspecialRtargRRSt working_prectsum_mantsum_expRaR=RuRRtmantexptbcRtsum_signtsum_bct sum_accuracytr((s/lib/python2.7/site-packages/sympy/core/evalf.pyt add_termss^)            cC sbt|}|rj|\}}t|||\}}}}t|||\} }} }|| || fS|jdt} d} |} x{t| d||dtExp1tmpc_expRtmpc_powt mpc_pow_mpfR!(RBRlRmRtbaseRRTR[R\R]R^tztcasetxretximRotyretyimtysize((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_pows~  ""       !"$     !$" $'!cC s\ddlm}m}t||r.t}nt||rFt}nt|jd}|d}t|||\}} } } | rd|kr|j |d}nt|j |||S|st||rt d |d fSt||rdStnt |} | dkr7|||td |d fS| dkrn|| }t|||\}} } } nx|||t} t | }| }|| |}||krD|jdrtd |d |d |tt| dn||jd tkr| d |d fS||7}t|||\}} } } qqqq| d |d fSqqWd S(sy This function handles sin and cos of complex arguments. TODO: should also handle tan of complex arguments. i(tcostsiniiRdii RsSIN/COStwantedRRN(NNNN(tsympyRRRORR$tNotImplementedErrorRwReRdt _eval_evalfRRhR>RRRR)R(RBRlRmRRtfuncRtxprecR[R\R]R^txsizetyRRRu((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_trigsP          !   cC sddlm}m}m}t|jdkrM|j}t|||S|jd}|d}t|||\}} } } | rt|||dt dt ||} t | |pt |} | d| | d|fSt |t dk}t t||t} t| }|||kr| t kr|tj|dt }t|||\}} } } |t|}t tt|t||t} n|}|r| t|||fS| d|dfSdS(Ni(tAbsRRiii Ri(RRRRRLRwRRet evalf_logRRRRRRRR>R3t NegativeOneRRRR Rh(RkRlRmRRRRR RRtxaccRoR[R\timaginary_termRtprec2R]((s/lib/python2.7/site-packages/sympy/core/evalf.pyR=s0   ' 'cC sz|jd}t||d|\}}}}||koFdknrOdS|r^tnt||td|dfS(Niii(N(NNNN(RwReRhRRR(RBRlRmRRRtreacctimacc((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_atanas " cC sXi}xK|jD]=\}}t|}|jrF|j|}n|||RRR(RER[R\R]R^(Rt have_partt max_imag_termt max_real_termR=(s/lib/python2.7/site-packages/sympy/core/evalf.pytfs/tquadtoscRtexcludeRRsbAn integrand of the form sin(A*x+B)*f(x) or cos(A*x+B)*f(x) is required for oscillatory quadraturetperiodterror(NN(NN(Rwt free_symbolsRfRRR{R RRRRRRR<tmatchRPR3tPiR RR>t_mpf_trealRRVRYRhtimag(RkRlRmtxlowtxhightdiffRRRRRRRRRRRZtquadrature_errorR[R]R\R^((RRRRR=s/lib/python2.7/site-packages/sympy/core/evalf.pyt do_integralsl          !$% !    "    " c C s|j}t|dks1t|ddkr:tn|}d}|jdt}xt|||}t|}||krPn||krPn|dkr|d9}n|t|d|7}t||}|d7}q[W|S(NiiiRii( tlimitsRLRRRXR$RcRYR{( RkRlRmR%R RGRRZRu((s/lib/python2.7/site-packages/sympy/core/evalf.pytevalf_integrals& (      c C sddlm}|||}|||}|j}|j}||}|rc|ddfS|j|j} t| dkr|| dfS|j|jkodknr|| dfS|jd} |jd} || | | |jfS(s8 Returns (h, g, p) where -- h is: > 0 for convergence of rate 1/factorial(n)**h < 0 for divergence of rate factorial(n)**(-h) = 0 for geometric or polynomial convergence or divergence -- abs(g) is: > 1 for geometric convergence of rate 1/h**n < 1 for geometric divergence of rate h**n = 1 for polynomial convergence or divergence (g < 0 indicates an alternating series) -- p is: > 1 for polynomial convergence of rate 1/n**h <= 1 for polynomial divergence of rate n**(-h) i(tPolyiiN(RR'tdegreeRhtLCR6t all_coeffs( tnumertdenomR8R'tnpoltdpolRTtqtratetconstanttpctqc((s/lib/python2.7/site-packages/sympy/core/evalf.pytcheck_convergence!s      ( c  sddlm}m}m}|tdkr=tdn|r\|j|||}n|||}|dkrtdn|j\}} |||||| t || |\} } } | dkrt d| n|j|d} | j stdn| dksE| dkrt | d krt | j|>| j} | }d }x^t | d kr| t |d 9} | t |d } || 7}|d 7}qnWt|| S| dk}t | d krt d t d | n| d ks4| d krH| rHt d | nd}t|}xtrd |t | j>| j}|gfd}t| t|dtgdd}WdQX|||}|dk r||krPn||7}|}q]W|jSdS(s Sum a rapidly convergent infinite hypergeometric series with given general term, e.g. e = hypsum(1/factorial(n), n). The quotient between successive terms must be a quotient of integer polynomials. i(Rt hypersimptlambdifyR sdoes not support inf precs#a hypergeometric series is requiredisSum diverges like (n!)^%is3Non rational term functionality is not implemented.iisSum diverges like (%i)^nsSum diverges like n^%iic sm|rUt|}|dct|d9<|dct|dsRlRm(RRLtallR%ReRtrewrite(RkRlRmRLR[R\R]R^((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_prods --c C smddlm}d|kr2|j|d}n|j}|j}t|dkslt|ddkrutn|tjkrt ddddfS|d}y|d\}}} | tj ks|t |krtnt ||t ||} |t| } t| dkr?t ||t || } n| dt|| dfSWn tk rh|d | } xotdd D]^} d | |}}|jd |d |d| dt\}}|j}|| krPqqWttt|d|d}t|||\}}}}|dkrB| }n|dkrX| }n||||fSXdS(Ni(RRdiiii ig@iiRR8tepst eval_integrali(RRRdtfunctionR%RLRR3RRRhR R7RKR>R{R1teuler_maclaurinRReR6(RkRlRmRRR%RR8RRRBRRRRGRRUterrR[R\R]R^((s/lib/python2.7/site-packages/sympy/core/evalf.pyt evalf_sumsF   (  !    "    cC s|d|}t|tr:|s'dS|jd|dfSd|krSi|ddS(Ni(t bernoulli(tProduct(RL(R(R( RRRRARRRRRtRationalR(tPow(tDummytSymbol(RR\R[(RR(tceilingtfloor(t Piecewise(tatanRR(tIntegralcS s|jd|dfS(N(RRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyttcS s"t|j|j|d|dfS(N(RRTR/Rh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS st|j|d|dfS(N(R RTRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS sdd|dfS(N(Rh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS std|dfS(N(RRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS std|dfS(N(RRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS st|d|dfS(N(R Rh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS st|d|dfS(N(RRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS sdtd|fS(N(RhR(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS std|dfS(N(RRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjcS std|dfS(N(RRh(R=RlRm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRiRjc s)ttj|jddt||S(NiR(RR3RRwR(R=RlRm(Ra(s/lib/python2.7/site-packages/sympy/core/evalf.pyRis(?t%sympy.functions.combinatorial.numbersR^tsympy.concrete.productsR_tsympy.concrete.summationsRLRRRRRRRRRARRRRRR`Rtsympy.core.powerRatsympy.core.symbolRbRcRRR\R[t&sympy.functions.elementary.exponentialRRt#sympy.functions.elementary.integersRdRet$sympy.functions.elementary.piecewiseRft(sympy.functions.elementary.trigonometricRgRRtsympy.integrals.integralsRhR]RRRRRRRxRyRzRRR&RWRQR R t evalf_table(R^R_RLRRRRRRARRRRRR`RRbRcRR\R[RRRdReRfRgRRRh((Ras/lib/python2.7/site-packages/sympy/core/evalf.pyt_create_evalf_tables\L           cC sddlm}m}y#t|j}||||}Wnetk rd|krt|jt||d}n|j|}|dkrt nt |dd}|dkrt n|\} } | j |s| j |rt n| dkrd} d} n0| j r:| j|dtj} |} nt | dkr[d} d} n0| j r| j|dtj} |} nt | | | | f}nX|jdrtd|td t|dptd td |tn|jd t} | ro| tkr!|}n<ttd tj| d}|dkr]|d8}nt||}n|jdrt|||n|S(Ni(R[R\RdRit allow_intsRs ### inputs ### outputi2s### rawtchopg rh g@iiR(RR[R\RuRtKeyErrorRdRRRhRtgetattrthasRft _to_mpmathRRRRR)RRNR7troundRtlog10RR(R=RlRmRRtrfRtxeRR[R\treprectimprecRxt chop_prec((s/lib/python2.7/site-packages/sympy/core/evalf.pyRes^                      #  t EvalfMixincB sVeZdZgZdddeededZeZdZdZ e dZ RS(s%Mixin class adding evalf capabililty.iidcC sNddlm}m} |dk r(|nd}|rOt|rOtdn|dkrt|| rddlm} |j d||||||} | | } | j d| } | St st nt |} it| t|td6|d 6|d 6|d 6}|dk r(||d Substitute numerical values for symbols, e.g. subs={x:3, y:1+pi}. The substitutions must be given as a dictionary. maxn= Allow a maximum temporary working precision of maxn digits (default=100) chop= Replace tiny real or imaginary parts in subresults by exact zeros (default=False) strict= Raise PrecisionExhausted if any subresult fails to evaluate to full accuracy, given the available maxprec (default=False) quad= Choose algorithm for numerical quadrature. By default, tanh-sinh quadrature is used. For oscillatory integrals on an infinite interval, try quad='osc'. verbose= Print debug information (default=False) Notes ===== When Floats are naively substituted into an expression, precision errors may adversely affect the result. For example, adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is then subtracted, the result will be 0. That is exactly what happens in the following: >>> from sympy.abc import x, y, z >>> values = {x: 1e16, y: 1, z: 1e16} >>> (x + y - z).subs(values) 0 Using the subs argument for evalf is the accurate way to evaluate such an expression: >>> (x + y - z).evalf(subs=values) 1.00000000000000 i(RtNumberis"subs must be given as a dictionaryi(t_magiRRxRRRdRiN(RRRRhR4t TypeErrorROtsympy.core.exprRReR}RuRvR-RYR7tLG10RRR{RR3RRA(tselfR8RdtmaxnRxRRRRRRRSRRlRmRZRBR[R\R]R^RT((s/lib/python2.7/site-packages/sympy/core/evalf.pyReXsN2!   $         cC s(|j|}|dkr$|}n|S(s@Helper for evalf. Does the same thing but takes binary precisionN(RRh(RRlR((s/lib/python2.7/site-packages/sympy/core/evalf.pyt_evalfs  cC sdS(N((RRl((s/lib/python2.7/site-packages/sympy/core/evalf.pyRscC sd}|r|jr|jSt|dr>t|j|Syat||i\}}}}|r|stt}nt||fS|rt|SttSWntk r|j |}|dkrt |n|j rt|j S|j\}}|r"|jr"t|j}n!|j r7|j }n t ||rd|jrdt|j}n!|j ry|j }n t |t||fSXdS(Nscannot convert to mpmath numbert _as_mpf_val(RRTRRRReRRRRRhRPRRRR (RRlRwterrmsgR[R\RoRB((s/lib/python2.7/site-packages/sympy/core/evalf.pyR|s@            N( R:R;t__doc__t __slots__RhRReR8RRRNR|(((s/lib/python2.7/site-packages/sympy/core/evalf.pyRSsc  icK st|j||S(s} Calls x.evalf(n, \*\*options). Both .n() and N() are equivalent to .evalf(); use the one that you like better. See also the docstring of .evalf() for information on the options. Examples ======== >>> from sympy import Sum, oo, N >>> from sympy.abc import k >>> Sum(1/k**k, (k, 1, oo)) Sum(k**(-k), (k, 1, oo)) >>> N(_, 4) 1.291 (R2Re(R=R8Rm((s/lib/python2.7/site-packages/sympy/core/evalf.pyRgs(wRt __future__RRRt mpmath.libmpRitmpmathRRRRRRRR R R R@R R RRRRRRRRRRRRRRRRRRR R!R"R#R$R%R&R'R(R)R*R5tmpmath.libmp.backendR+tmpmath.libmp.libmpcR,tmpmath.libmp.libmpfR-R.tmpmath.libmp.gammazetaR/t compatibilityR0R1R2t singletonR3tsympy.utilities.iterablesR4RRRRRXR<RtArithmeticErrorR9R>RRHRVRMRcRqRvRxRyRzR~RRRRRRRRRRRRRR R RR$R&R4RKRQRWR]RhRuRvRetobjectRRg(((s/lib/python2.7/site-packages/sympy/core/evalf.pytsz @    !  &           h  S * r j = $    _  & L .  ; :