Ticket #5777: trac_5777-02-precision.patch

File trac_5777-02-precision.patch, 30.9 KB (added by burcin, 11 years ago)

allow setting precision for numerical approximation

  • c_lib/include/ginac_wrap.h

    # HG changeset patch
    # User Burcin Erocal <burcin@erocal.org>
    # Date 1239629705 -7200
    # Node ID 4e0b7c01999d325420e21568221b8d13cd635677
    # Parent  202601ebc70b20cdac11dc4e6081b1362f6c531b
    Allow setting precision for numerical evaluation of pynac expressions.
    
    diff --git a/c_lib/include/ginac_wrap.h b/c_lib/include/ginac_wrap.h
    a b  
    158158         *AND* sets success to true on success, and false on failure
    159159         if e is not coercible to a double
    160160  */     
    161   ex f = e.evalf();
     161  ex f = e.evalf(0, 53);
    162162  if (is_a<numeric>(f)) {
    163163    *success = true;
    164164    return (ex_to<numeric>(f)).to_double();
  • sage/libs/ginac/decl.pxi

    diff --git a/sage/libs/ginac/decl.pxi b/sage/libs/ginac/decl.pxi
    a b  
    7070        int nops()                    except +
    7171        GEx op(int i)                 except +
    7272        GEx eval(int level)           except +
    73         GEx evalf(int level)          except +
     73        GEx evalf(int level, int prec) except +
    7474        GEx conjugate()               except +
    7575        GEx real_part()               except +
    7676        GEx imag_part()               except +
  • sage/misc/functional.py

    diff --git a/sage/misc/functional.py b/sage/misc/functional.py
    a b  
    757757   
    758758        sage: (pi^2 + e).n()
    759759        12.5878862295484
     760
     761    TESTS::
     762       
     763        sage: numerical_approx(I)
     764        1.00000000000000*I
     765        sage: x = QQ['x'].gen()
     766        sage: F.<k> = NumberField(x^2+2, embedding=sqrt(CC(2))*CC.0)
     767        sage: numerical_approx(k)
     768        1.41421356237309*I
     769
     770        sage: type(numerical_approx(CC(1/2)))
     771        <type 'sage.rings.complex_number.ComplexNumber'>
    760772    """
    761773    if prec is None:
    762774        if digits is None:
     
    768780    except AttributeError:
    769781        from sage.rings.complex_double import is_ComplexDoubleElement
    770782        from sage.rings.complex_number import is_ComplexNumber
    771         if is_ComplexNumber(x) or is_ComplexDoubleElement(x):
    772             return sage.rings.complex_field.ComplexField(prec)(x)
    773         else:
    774             return sage.rings.real_mpfr.RealField_constructor(prec)(x)
     783        if not (is_ComplexNumber(x) or is_ComplexDoubleElement(x)):
     784            try:
     785                return sage.rings.real_mpfr.RealField_constructor(prec)(x)
     786            except TypeError:
     787                pass
     788        return sage.rings.complex_field.ComplexField(prec)(x)
    775789
    776790n = numerical_approx
    777791N = numerical_approx
  • sage/rings/complex_field.py

    diff --git a/sage/rings/complex_field.py b/sage/rings/complex_field.py
    a b  
    3333AlgebraicReal = None
    3434AA = None
    3535QQbar = None
     36NSR = None
    3637CDF = CLF = RLF = None
    3738def late_import():
    3839    global NumberFieldElement_quadratic
    3940    global AlgebraicNumber_base
    4041    global AlgebraicNumber
    4142    global AlgebraicReal
    42     global AA, QQbar
     43    global AA, QQbar, NSR
    4344    global CLF, RLF, CDF
    4445    if NumberFieldElement_quadratic is None:
    4546        import sage.rings.number_field.number_field_element_quadratic as nfeq
     
    5051        AlgebraicReal = sage.rings.qqbar.AlgebraicReal
    5152        AA = sage.rings.qqbar.AA
    5253        QQbar = sage.rings.qqbar.QQbar
     54        import sage.symbolic.ring
     55        NSR = sage.symbolic.ring.NSR
    5356        from real_lazy import CLF, RLF
    5457        from complex_double import CDF
    5558
     
    309312        if is_ComplexField(S) and S._prec >= self._prec:
    310313            return self._generic_convert_map(S)
    311314        late_import()
    312         if S in [AA, QQbar, CLF, RLF] or (S == CDF and self._prec <= 53):
     315        if S in [AA, QQbar, CLF, RLF, NSR] or (S == CDF and self._prec <= 53):
    313316            return self._generic_convert_map(S)
    314317        return self._coerce_map_via([CLF], S)
    315318       
  • sage/symbolic/expression.pxd

    diff --git a/sage/symbolic/expression.pxd b/sage/symbolic/expression.pxd
    a b  
    66cdef class Expression(CommutativeRingElement):
    77    cdef GEx _gobj
    88    cdef Expression coerce_in(self, z)
     9    cpdef object _eval_self(self, R)
    910    cpdef bint is_polynomial(self, var)
    1011    cpdef bint is_relational(self)
    1112    cpdef object pyobject(self)
  • sage/symbolic/expression.pyx

    diff --git a/sage/symbolic/expression.pyx b/sage/symbolic/expression.pyx
    a b  
    271271            return n
    272272        return sage.rings.rational.Rational(n)
    273273
     274    cpdef _eval_self(self, R):
     275        """
     276        Evaluate this expression numerically, and try to coerce it to R.
     277
     278        EXAMPLES::
     279
     280            sage: var('x,y,z',ns=1)
     281            (x, y, z)
     282            sage: sin(x).subs(x=5)._eval_self(RR)
     283            -0.958924274663138
     284            sage: gamma(x).subs(x=I)._eval_self(CC)
     285            -0.154949828301811 - 0.498015668118356*I
     286            sage: x._eval_self(CC)
     287            Traceback (most recent call last):
     288            ...
     289            TypeError: Cannot evaluate symbolic expression to a numeric value.
     290        """
     291        cdef GEx res = self._gobj.evalf(0, R.prec())
     292        if is_a_numeric(res):
     293            return R(py_object_from_numeric(res))
     294        else:
     295            raise TypeError, "Cannot evaluate symbolic expression to a numeric value."
     296
    274297    def _mpfr_(self, R):
    275298        """
    276         This is a very preliminary conversion to real numbers.  It
    277         doesn't unwind an expression, so is fairly useless.
     299        Return a numerical approximation to this expression in the RealField R.
     300
     301        The precision of the approximation is determined by the precision of
     302        the input R.
    278303       
    279         EXAMPLES:
     304        EXAMPLES::
     305
    280306            sage: var('x',ns=1); S = parent(x)
    281307            x
    282308            sage: RealField(200)(S(1/11))
    283309            0.090909090909090909090909090909090909090909090909090909090909
    284310
    285         This illustrates that this function is not done yet:
    286311            sage: a = S(3).sin(); a
    287312            sin(3)
    288313            sage: RealField(200)(a)
    289             Traceback (most recent call last):
    290             ...
    291             TypeError: self must be a numeric expression
     314            0.14112000805986722210074480280811027984693326425226558415188
     315            sage: a._mpfr_(RealField(100))
     316            0.14112000805986722210074480281
    292317        """
    293         # TODO: This is *not* good enough.
    294         return R(self.pyobject())
     318        return self._eval_self(R)
     319
     320    def _complex_mpfr_field_(self, R):
     321        """
     322        Return a numerical approximation to this expression in the given
     323        ComplexField R.
     324
     325        The precision of the approximation is determined by the precision of
     326        the input R.
     327       
     328        EXAMPLES::
     329
     330            sage: var('x',ns=1); S = parent(x)
     331            x
     332            sage: ComplexField(200)(S(1/11))
     333            0.090909090909090909090909090909090909090909090909090909090909
     334            sage: zeta(x).subs(x=I)._complex_mpfr_field_(ComplexField(70))
     335            0.0033002236853241028742 - 0.41815544914132167669*I
     336            sage: gamma(x).subs(x=I)._complex_mpfr_field_(ComplexField(60))
     337            -0.15494982830181069 - 0.49801566811835604*I
     338            sage: log(x).subs(x=I)._complex_mpfr_field_(ComplexField(50))
     339            1.5707963267949*I
     340
     341        """
     342        return self._eval_self(R)
     343
     344    def _complex_double_(self, R):
     345        """
     346        Return a numerical approximation to this expression in the given
     347        Complex Double Field R.
     348
     349        EXAMPLES::
     350
     351            sage: var('x',ns=1); S = parent(x)
     352            x
     353            sage: CDF(S(1/11))
     354            0.0909090909091
     355            sage: zeta(x).subs(x=I)._complex_double_(CDF)
     356            0.00330022368532 - 0.418155449141*I
     357            sage: gamma(x).subs(x=I)._complex_double_(CDF)
     358            -0.154949828302 - 0.498015668118*I
     359            sage: log(x).subs(x=I)._complex_double_(CDF)
     360            1.57079632679*I
     361        """
     362        return self._eval_self(R)
    295363
    296364    def __float__(self):
    297365        """
     
    314382            ...
    315383            TypeError: float() argument must be a string or a number
    316384            sage: float(SR(RIF(2)))
    317             Traceback (most recent call last):
    318             ...
    319             TypeError: float() argument must be a string or a number
     385            2.0
    320386        """
    321387        cdef bint success
    322388        cdef double ans = GEx_to_double(self._gobj, &success)
     
    16451711        """
    16461712        Return a numerical approximation of self.
    16471713
    1648         TESTS:
     1714        ALIAS: .numerical_approx()
     1715
     1716        EXAMPLES::
     1717
     1718            sage: var('x', ns=1)
     1719            x
     1720            sage: sin(x).subs(x=5).n()
     1721            -0.958924274663138
     1722            sage: sin(x).subs(x=5).n(100)
     1723            -0.95892427466313846889315440616
     1724            sage: sin(x).subs(x=5).n(digits=50)
     1725            -0.95892427466313846889315440615599397335246154396460
     1726            sage: zeta(x).subs(x=2).numerical_approx(digits=50)
     1727            1.6449340668482264364724151666460251892189499012068
     1728
     1729        TESTS::
    16491730
    16501731        We test the evaluation of different infinities available in pynac::
    1651             sage: var('x', ns=1)
    1652             x
    16531732            sage: t = x - oo; t
    16541733            -Infinity
    16551734            sage: t.n()
     
    16631742            sage: t.n()
    16641743            Infinity
    16651744        """
    1666         # TODO: prec and digits parameters
    1667         return new_Expression_from_GEx(self._gobj.evalf(0))
     1745        if prec is None:
     1746            if digits is None:
     1747                prec = 53
     1748            else:
     1749                prec = int((digits+1) * 3.32192) + 1
     1750        return new_Expression_from_GEx(self._gobj.evalf(0, prec))
     1751
     1752    numerical_approx = n
    16681753
    16691754    def function(self, *args):
    16701755        """
     
    20312116
    20322117    def sin(self):
    20332118        """
    2034         EXAMPLES:
     2119        EXAMPLES::
     2120
    20352121            sage: var('x, y', ns=1); S = parent(x)
    20362122            (x, y)
    20372123            sage: sin(x^2 + y^2)
     
    20412127            sage: sin(S(1))
    20422128            sin(1)
    20432129            sage: sin(S(RealField(150)(1)))
     2130            sin(1.0000000000000000000000000000000000000000000)
     2131
     2132        In order to get a numeric approximation use .n()::
     2133
     2134            sage: sin(S(1)).n(150)
    20442135            0.84147098480789650665250232163029899962256306
     2136
    20452137        """
    20462138        return new_Expression_from_GEx(g_sin(self._gobj))
    20472139
     
    20492141        """
    20502142        Return the cosine of self.
    20512143       
    2052         EXAMPLES:
     2144        EXAMPLES::
     2145
    20532146            sage: var('x, y', ns=1); S = parent(x)
    20542147            (x, y)
    20552148            sage: cos(x^2 + y^2)
     
    20592152            sage: cos(S(1))
    20602153            cos(1)
    20612154            sage: cos(S(RealField(150)(1)))
     2155            cos(1.0000000000000000000000000000000000000000000)
     2156
     2157        In order to get a numeric approximation use .n()::
     2158
     2159            sage: cos(S(1)).n(150)
    20622160            0.54030230586813971740093660744297660373231042
    2063             sage: S(RR(1)).cos()
     2161            sage: S(RR(1)).cos().n()
    20642162            0.540302305868140
    2065             sage: S(float(1)).cos()
    2066             0.54030230586813977
     2163            sage: S(float(1)).cos().n()
     2164            0.540302305868140
    20672165        """
    20682166        return new_Expression_from_GEx(g_cos(self._gobj))
    20692167
    20702168    def tan(self):
    20712169        """
    2072         EXAMPLES:
     2170        EXAMPLES::
     2171
    20732172            sage: var('x, y', ns=1); S = parent(x)
    20742173            (x, y)
    20752174            sage: tan(x^2 + y^2)
     
    20812180            sage: tan(S(1))
    20822181            tan(1)
    20832182            sage: tan(S(RealField(150)(1)))
     2183            tan(1.0000000000000000000000000000000000000000000)
     2184       
     2185        Use .n() to get a numerical approximation::
     2186       
     2187            sage: tan(S(1)).n(150)
    20842188            1.5574077246549022305069748074583601730872508
    20852189        """
    20862190        try:
     
    20932197        Return the arcsin of x, i.e., the number y between -pi and pi
    20942198        such that sin(y) == x.
    20952199       
    2096         EXAMPLES:
     2200        EXAMPLES::
     2201
    20972202            sage: x = var('x', ns=1); SR = x.parent()
    20982203            sage: x.arcsin()
    20992204            arcsin(x)
    21002205            sage: SR(0.5).arcsin()
     2206            arcsin(0.500000000000000)
     2207
     2208        Use .n() to get a numerical approximation::
     2209
     2210            sage: SR(0.5).arcsin().n()
    21012211            0.523598775598299
     2212
    21022213            sage: SR(0.999).arcsin()
     2214            arcsin(0.999000000000000)
     2215            sage: SR(-0.999).arcsin()
     2216            -arcsin(0.999000000000000)
     2217            sage: SR(0.999).arcsin().n()
    21032218            1.52607123962616
    2104             sage: SR(-0.999).arcsin()
    2105             -1.52607123962616
    21062219        """
    21072220        return new_Expression_from_GEx(g_asin(self._gobj))
    21082221
     
    21102223        """
    21112224        Return the arc cosine of self.
    21122225
    2113         EXAMPLES:
     2226        EXAMPLES::
     2227
    21142228            sage: x = var('x', ns=1); S = x.parent()
    21152229            sage: x.arccos()
    21162230            arccos(x)
     
    21192233            sage: S(1/2).arccos()
    21202234            1/3*pi
    21212235            sage: S(0.4).arccos()
     2236            arccos(0.400000000000000)
     2237
     2238        Use .n() to get a numerical approximation::
     2239
     2240            sage: S(0.4).arccos().n()
    21222241            1.15927948072741
    21232242            sage: plot(lambda x: S(x).arccos(), -1,1)
    21242243        """
     
    21282247        """
    21292248        Return the arc tangent of self.
    21302249
    2131         EXAMPLES:
     2250        EXAMPLES::
     2251
    21322252            sage: x = var('x', ns=1); S = x.parent()
    21332253            sage: x.arctan()
    21342254            arctan(x)
     
    21372257            sage: S(1/2).arctan()
    21382258            arctan(1/2)
    21392259            sage: S(0.5).arctan()
     2260            arctan(0.500000000000000)
     2261
     2262        Use .n() to get a numerical approximation::
     2263
     2264            sage: S(0.5).arctan().n()
    21402265            0.463647609000806
    21412266            sage: plot(lambda x: S(x).arctan(), -20,20)
    21422267        """
     
    21462271        """
    21472272        Return the inverse of the 2-variable tan function on self and x.
    21482273       
    2149         EXAMPLES:
     2274        EXAMPLES::
     2275
    21502276            sage: var('x,y', ns=1); S = parent(x)
    21512277            (x, y)
    21522278            sage: x.arctan2(y)
     
    21562282            sage: maxima.eval('atan2(1/2,1/2)')
    21572283            '%pi/4'
    21582284
     2285            sage: S(-0.7).arctan2(S(-0.6))
     2286            -pi + arctan(1.16666666666667)
     2287
     2288        Use .n() to get a numerical approximation::
     2289
     2290            sage: S(-0.7).arctan2(S(-0.6)).n()
     2291            -2.27942259892257
     2292
    21592293        TESTS:
     2294
    21602295        We compare a bunch of different evaluation points between
    2161         Sage and Maxima:
    2162             sage: S(-0.7).arctan2(S(-0.6))
    2163             -pi + 0.862170054667226
    2164            
     2296        Sage and Maxima::
     2297
    21652298            sage: float(S(0.7).arctan2(0.6))
    21662299            0.8621700546672264
    21672300            sage: maxima('atan2(0.7,0.6)')
     
    22052338
    22062339        We have $\sinh(x) = (e^{x} - e^{-x})/2$.
    22072340
    2208         EXAMPLES:
     2341        EXAMPLES::
     2342
    22092343            sage: x = var('x', ns=1); S = x.parent()
    22102344            sage: x.sinh()
    22112345            sinh(x)
     
    22142348            sage: S(0).sinh()
    22152349            0
    22162350            sage: S(1.0).sinh()
     2351            sinh(1.00000000000000)
     2352
     2353        Use .n() to get a numerical approximation::
     2354
     2355            sage: S(1.0).sinh().n()
    22172356            1.17520119364380
    22182357            sage: maxima('sinh(1.0)')
    22192358            1.175201193643801
     2359
    22202360            sage: S(1.0000000000000000000000000).sinh()
     2361            sinh(1.0000000000000000000000000)
     2362            sage: S(1).sinh().n(90)
    22212363            1.1752011936438014568823819
    22222364            sage: S(RIF(1)).sinh()
    2223             1.175201193643802?
     2365            sinh(1)
     2366            sage: S(RIF(1)).sinh().n()
     2367            1.17520119364380
    22242368            sage: plot(lambda x: S(x).sinh(), -1, 1)
    22252369        """
    22262370        return new_Expression_from_GEx(g_sinh(self._gobj))
     
    22312375
    22322376        We have $\sinh(x) = (e^{x} + e^{-x})/2$.
    22332377
    2234         EXAMPLES:
     2378        EXAMPLES::
     2379
    22352380            sage: x = var('x', ns=1); S = x.parent()
    22362381            sage: x.cosh()
    22372382            cosh(x)
     
    22402385            sage: S(0).cosh()
    22412386            1
    22422387            sage: S(1.0).cosh()
     2388            cosh(1.00000000000000)
     2389
     2390        Use .n() to get a numerical approximation::
     2391
     2392            sage: S(1.0).cosh().n()
    22432393            1.54308063481524
    22442394            sage: maxima('cosh(1.0)')
    22452395            1.543080634815244
    22462396            sage: S(1.0000000000000000000000000).cosh()
     2397            cosh(1.0000000000000000000000000)
     2398            sage: S(1).cosh().n(90)
    22472399            1.5430806348152437784779056
    22482400            sage: S(RIF(1)).cosh()
    2249             1.543080634815244?
     2401            cosh(1)
     2402            sage: S(RIF(1)).cosh().n()
     2403            1.54308063481524
    22502404            sage: plot(lambda x: S(x).cosh(), -1, 1)
    22512405        """
    22522406        return new_Expression_from_GEx(g_cosh(self._gobj))
     
    22572411
    22582412        We have $\tanh(x) = \sinh(x) / \cosh(x)$.
    22592413
    2260         EXAMPLES:
     2414        EXAMPLES::
     2415
    22612416            sage: x = var('x', ns=1); S = x.parent()
    22622417            sage: x.tanh()
    22632418            tanh(x)
     
    22662421            sage: S(0).tanh()
    22672422            0
    22682423            sage: S(1.0).tanh()
     2424            tanh(1.00000000000000)
     2425
     2426        Use .n() to get a numerical approximation::
     2427
     2428            sage: S(1.0).tanh().n()
    22692429            0.761594155955765
    22702430            sage: maxima('tanh(1.0)')
    22712431            .7615941559557649
     
    22772437        """
    22782438        Return the inverse hyperbolic sine of self.
    22792439       
    2280         EXAMPLES:
     2440        EXAMPLES::
     2441
    22812442            sage: x = var('x', ns=1); S = x.parent()
    22822443            sage: x.arcsinh()
    22832444            arcsinh(x)
     
    22862447            sage: S(1).arcsinh()
    22872448            arcsinh(1)
    22882449            sage: S(1.0).arcsinh()
     2450            arcsinh(1.00000000000000)
     2451
     2452        Use .n() to get a numerical approximation::
     2453
     2454            sage: S(1.0).arcsinh().n()
    22892455            0.881373587019543
    22902456            sage: maxima('asinh(1.0)')
    22912457            .8813735870195429
    22922458
    2293         Sage automatically applies certain identies:
     2459        Sage automatically applies certain identies::
    22942460            sage: S(3/2).arcsinh().cosh()
    22952461            1/2*sqrt(13)
    22962462        """
     
    23002466        """
    23012467        Return the inverse hyperbolic cosine of self.
    23022468
    2303         EXAMPLES:
     2469        EXAMPLES::
     2470
    23042471            sage: x = var('x', ns=1); S = x.parent()
    23052472            sage: x.arccosh()
    23062473            arccosh(x)
     
    23092476            sage: S(1/2).arccosh()
    23102477            arccosh(1/2)
    23112478            sage: S(CDF(1/2)).arccosh()
     2479            arccosh(0.5)
     2480
     2481        Use .n() to get a numerical approximation::
     2482
     2483            sage: S(CDF(1/2)).arccosh().n()
    23122484            1.0471975512*I
    23132485            sage: maxima('acosh(0.5)')
    23142486            1.047197551196598*%i
     
    23192491        """
    23202492        Return the inverse hyperbolic tangent of self.
    23212493
    2322         EXAMPLES:
     2494        EXAMPLES::
     2495
    23232496            sage: x = var('x', ns=1); S = x.parent()
    23242497            sage: x.arctanh()
    23252498            arctanh(x)
     
    23282501            sage: S(1/2).arctanh()
    23292502            arctanh(1/2)
    23302503            sage: S(0.5).arctanh()
     2504            arctanh(0.500000000000000)
     2505
     2506        Use .n() to get a numerical approximation::
     2507
     2508            sage: S(0.5).arctanh().n()
    23312509            0.549306144334055
    23322510            sage: S(0.5).arctanh().tanh()
    23332511            0.500000000000000
     
    23412519        Return exponential function of self, i.e., e to the
    23422520        power of self.
    23432521
    2344         EXAMPLES:
     2522        EXAMPLES::
     2523
    23452524            sage: x = var('x', ns=1); S = x.parent()
    23462525            sage: x.exp()
    23472526            e^x
     
    23502529            sage: S(1/2).exp()
    23512530            e^(1/2)
    23522531            sage: S(0.5).exp()
     2532            e^0.500000000000000
     2533
     2534           
     2535        Use .n() to get a numerical approximation::
     2536
     2537            sage: S(0.5).exp().n()
    23532538            1.64872127070013
     2539            sage: math.exp(0.5)
     2540            1.6487212707001282
     2541
    23542542            sage: S(0.5).exp().log()
    23552543            0.500000000000000
    2356             sage: math.exp(0.5)
    2357             1.6487212707001282
    23582544            sage: plot(lambda x: S(x).exp(), -2,1)
    23592545        """
    23602546        return new_Expression_from_GEx(g_exp(self._gobj))
     
    23632549        """
    23642550        Return the logarithm of self.
    23652551
    2366         EXAMPLES:
     2552        EXAMPLES::
     2553
    23672554            sage: x, y = var('x, y', ns=1); S = x.parent()
    23682555            sage: x.log()
    23692556            log(x)
     
    23782565            sage: S(1/2).log()
    23792566            log(1/2)
    23802567            sage: S(0.5).log()
     2568            log(0.500000000000000)
     2569
     2570        Use .n() to get a numerical approximation::
     2571
     2572            sage: S(0.5).log().n()
    23812573            -0.693147180559945
    23822574            sage: S(0.5).log().exp()
    23832575            0.500000000000000
     
    23892581
    23902582    def zeta(self):
    23912583        """
    2392         EXAMPLES:
     2584        EXAMPLES::
    23932585            sage: x, y = var('x, y', ns=1); S = x.parent()
    23942586            sage: (x/y).zeta()
    23952587            zeta(x/y)
     
    23982590            sage: S(3).zeta()
    23992591            zeta(3)
    24002592            sage: S(CDF(0,1)).zeta()
     2593            zeta(1.0*I)
     2594            sage: S(CDF(0,1)).zeta().n()
    24012595            0.00330022368532 - 0.418155449141*I
    24022596            sage: CDF(0,1).zeta()
    24032597            0.00330022368532 - 0.418155449141*I
    24042598            sage: plot(lambda x: S(x).zeta(), -10,10).show(ymin=-3,ymax=3)
     2599
     2600        TESTS::
     2601           
     2602            sage: t = S(1).zeta(); t
     2603            zeta(1)
     2604            sage: t.n()
     2605            Infinity
    24052606        """
    24062607        _sig_on
    24072608        cdef GEx x = g_zeta(self._gobj)
     
    24802681            sage: S(10).gamma()
    24812682            362880
    24822683            sage: S(10.0r).gamma()
     2684            gamma(10.0)
     2685
     2686        Use .n() to get a numerical approximation::
     2687
     2688            sage: S(10.0r).gamma().n()
    24832689            362880.000000000
    24842690            sage: S(CDF(1,1)).gamma()
     2691            gamma(1.0 + 1.0*I)
     2692            sage: S(CDF(1,1)).gamma().n()
    24852693            0.498015668118 - 0.154949828302*I
    24862694
    24872695            sage: gp('gamma(1+I)') # 32-bit
  • sage/symbolic/function.pyx

    diff --git a/sage/symbolic/function.pyx b/sage/symbolic/function.pyx
    a b  
    6969            sage: foo(x)
    7070            5
    7171
    72             sage: foo = nfunction("foo", 1, evalf_func=lambda x: 5)
     72            sage: def evalf_f(x, prec=0): return 6
     73            sage: foo = nfunction("foo", 1, evalf_func=evalf_f)
    7374            sage: foo(x)
    7475            foo(x)
    7576            sage: foo(x).n()
    76             5
     77            6
    7778
    7879            sage: foo = nfunction("foo", 1, conjugate_func=ev)
    7980            sage: foo(x).conjugate()
  • sage/symbolic/pynac.pyx

    diff --git a/sage/symbolic/pynac.pyx b/sage/symbolic/pynac.pyx
    a b  
    1919from sage.structure.element import Element
    2020from sage.rings.integer_ring import ZZ
    2121from sage.rings.integer cimport Integer
    22 from sage.rings.real_mpfr import RR, RealField
     22from sage.rings.real_mpfr import RR, RealField_constructor
    2323from sage.rings.all import CC
    2424from sage.calculus.all import SR
    2525
     
    498498    bint py_is_prime(object x)
    499499    object py_numer(object x)
    500500    object py_denom(object x)
    501     object py_float(object x)
     501    object py_float(object x, int prec) except +
    502502    object py_RDF_from_double(double x)
    503503    object py_factorial(object x)
    504504    object py_doublefactorial(object x)
     
    535535    object py_li2(object x)
    536536    object py_psi(object x)
    537537    object py_psi2(object x, object y)
    538     object py_eval_pi(long int)
    539     object py_eval_euler_gamma(long int)
    540     object py_eval_catalan(long int)
     538    object py_eval_pi(int)
     539    object py_eval_euler_gamma(int)
     540    object py_eval_catalan(int)
    541541    object py_eval_unsigned_infinity()
    542542    object py_eval_infinity()
    543543    object py_eval_neg_infinity()
     
    809809    except AttributeError:
    810810        return 1
    811811
    812 cdef public object py_float(object n):
    813     return float(n)
     812cdef public object py_float(object n, int prec) except +:
     813    """
     814    Evaluate pynac numeric objects numerically.
     815
     816    TESTS::
     817
     818        sage: from sage.symbolic.pynac import py_float_for_doctests as py_float
     819        sage: py_float(I, 10)
     820        1.0*I
     821        sage: py_float(pi, 100)
     822        3.1415926535897932384626433833
     823        sage: py_float(CDF(10), 53)
     824        10.0
     825        sage: type(py_float(CDF(10), 53))
     826        <type 'sage.rings.complex_double.ComplexDoubleElement'>
     827        sage: py_float(CC(1/2), 53)
     828        0.500000000000000
     829        sage: type(py_float(CC(1/2), 53))
     830        <type 'sage.rings.complex_number.ComplexNumber'>
     831    """
     832    if isinstance(n, (int, long, float)):
     833        return RealField_constructor(prec)(n)
     834    from sage.structure.coerce import parent
     835    if hasattr(parent(n), 'to_prec'):
     836        return parent(n).to_prec(prec)(n)
     837    from sage.misc.functional import numerical_approx
     838    return numerical_approx(n, prec)
     839
     840def py_float_for_doctests(n, prec):
     841    """
     842    This function is for testing py_float.
     843
     844    EXAMPLES::
     845       
     846        sage: from sage.symbolic.pynac import py_float_for_doctests
     847        sage: py_float_for_doctests(pi, 80)
     848        3.1415926535897932384626
     849    """
     850    return py_float(n, prec)
    814851
    815852# TODO: Optimize this
    816853from sage.rings.real_double import RDF
     
    889926        return cos(float(x))
    890927
    891928cdef public object py_zeta(object x):
     929    """
     930    Return the value of the zeta function at the given value.
     931
     932    The value is expected to be a numerical object, in RR, CC, RDF or CDF,
     933    different from 1.
     934
     935    TESTS::
     936
     937        sage: from sage.symbolic.pynac import py_zeta_for_doctests as py_zeta
     938        sage: py_zeta(CC.0)
     939        0.00330022368532410 - 0.418155449141322*I
     940        sage: py_zeta(CDF(5))
     941        1.03692775514
     942        sage: py_zeta(RealField(100)(5))
     943        1.0369277551433699263313654865
     944    """
    892945    try:
    893946        return x.zeta()
    894947    except AttributeError:
    895         return RR(x).zeta()
     948        pass
     949    # zeta() evaluates it's argument before calling this, so we should never
     950    # end up here. Precision is not a problem here, since zeta() passes that
     951    # on when it calls evalf() on the argument.
     952    raise RuntimeError, "py_zeta() received non evaluated argument"
     953
     954def py_zeta_for_doctests(x):
     955    """
     956    This function is for testing py_zeta().
     957
     958    EXAMPLES::
     959
     960        sage: from sage.symbolic.pynac import py_zeta_for_doctests
     961        sage: py_zeta_for_doctests(CC.0)
     962        0.00330022368532410 - 0.418155449141322*I
     963    """
     964    return py_zeta(x)
    896965
    897966cdef public object py_exp(object x):
     967    """
     968    Return the value of the exp function at the given value.
     969
     970    The value is expected to be a numerical object, in RR, CC, RDF or CDF.
     971
     972    TESTS::
     973
     974        sage: from sage.symbolic.pynac import py_exp_for_doctests as py_exp
     975        sage: py_exp(CC(1))
     976        2.71828182845905
     977        sage: py_exp(CC(.5*I))
     978        0.877582561890373 + 0.479425538604203*I
     979    """
    898980    try:
    899981        return x.exp()
    900982    except AttributeError:
    901         return RR(x).exp()
     983        pass
     984    # exp() evaluates it's argument before calling this, so we should never
     985    # end up here. Precision is not a problem here, since exp() passes that
     986    # on when it calls evalf() on the argument.
     987    raise RuntimeError, "py_exp() received non evaluated argument"
     988
     989def py_exp_for_doctests(x):
     990    """
     991    This function tests py_exp.
     992
     993    EXAMPLES::
     994
     995        sage: from sage.symbolic.pynac import py_exp_for_doctests
     996        sage: py_exp_for_doctests(CC(2))
     997        7.38905609893065
     998    """
     999    return py_exp(x)
    9021000
    9031001cdef public object py_log(object x):
     1002    """
     1003    Return the value of the log function at the given value.
     1004
     1005    The value is expected to be a numerical object, in RR, CC, RDF or CDF.
     1006
     1007    TESTS::
     1008
     1009        sage: from sage.symbolic.pynac import py_log_for_doctests as py_log
     1010        sage: py_log(CC(e))
     1011        1.00000000000000
     1012        sage: py_log(CC.0)
     1013        1.57079632679490*I
     1014    """
    9041015    try:
    9051016        return x.log()
    9061017    except AttributeError:
    907         return RR(x).log()
     1018        pass
     1019    # log() evaluates it's argument before calling this, so we should never
     1020    # end up here. Precision is not a problem here, since log() passes that
     1021    # on when it calls evalf() on the argument.
     1022    raise RuntimeError, "py_log() received non evaluated argument"
    9081023
     1024def py_log_for_doctests(x):
     1025    """
     1026    This function tests py_log.
     1027
     1028    EXAMPLES::
     1029
     1030        sage: from sage.symbolic.pynac import py_log_for_doctests
     1031        sage: py_log_for_doctests(CC(e))
     1032        1.00000000000000
     1033    """
     1034    return py_log(x)
    9091035
    9101036cdef public object py_tan(object x):
    9111037    try:
     
    10681194# Constants
    10691195##################################################################
    10701196
    1071 cdef int prec(long ndigits):
    1072     return <int>((ndigits+1) * 3.32192 + 1)
     1197cdef public object py_eval_pi(int prec):
     1198    """
     1199    Return the value of pi with the given precision.
    10731200
    1074 cdef public object py_eval_pi(long ndigits):
    1075     return RealField(prec(ndigits)).pi()
     1201    TESTS::
     1202
     1203        sage: from sage.symbolic.pynac import py_eval_pi_for_doctests as py_eval_pi
     1204        sage: py_eval_pi(50)
     1205        3.1415926535898
     1206        sage: py_eval_pi(100)
     1207        3.1415926535897932384626433833
     1208    """
     1209    return RealField_constructor(prec).pi()
     1210
     1211def py_eval_pi_for_doctests(prec):
     1212    """
     1213    This function tests py_eval_pi.
     1214
     1215    EXAMPLES::
     1216
     1217        sage: from sage.symbolic.pynac import py_eval_pi_for_doctests
     1218        sage: py_eval_pi_for_doctests(40)
     1219        3.1415926536
     1220    """
     1221    return py_eval_pi(prec)
    10761222   
    1077 cdef public object py_eval_euler_gamma(long ndigits):
    1078     return RealField(prec(ndigits)).euler_constant()
     1223cdef public object py_eval_euler_gamma(int prec):
     1224    """
     1225    Return the value of euler_gamma with the given precision.
    10791226
    1080 cdef public object py_eval_catalan(long ndigits):
    1081     return RealField(prec(ndigits)).catalan_constant()
     1227    TESTS::
    10821228
     1229        sage: from sage.symbolic.pynac import py_eval_euler_gamma_for_doctests as py_eval_euler_gamma
     1230        sage: py_eval_euler_gamma(50)
     1231        0.57721566490153
     1232        sage: py_eval_euler_gamma(100)
     1233        0.57721566490153286060651209008
     1234    """
     1235    return RealField_constructor(prec).euler_constant()
     1236
     1237def py_eval_euler_gamma_for_doctests(prec):
     1238    """
     1239    This function tests py_eval_euler_gamma.
     1240
     1241    EXAMPLES::
     1242
     1243        sage: from sage.symbolic.pynac import py_eval_euler_gamma_for_doctests
     1244        sage: py_eval_euler_gamma_for_doctests(40)
     1245        0.57721566490
     1246    """
     1247    return py_eval_euler_gamma(prec)
     1248   
     1249cdef public object py_eval_catalan(int prec):
     1250    """
     1251    Return the value of catalan with the given precision.
     1252
     1253    TESTS::
     1254
     1255        sage: from sage.symbolic.pynac import py_eval_catalan_for_doctests as py_eval_catalan
     1256        sage: py_eval_catalan(50)
     1257        0.91596559417722
     1258        sage: py_eval_catalan(100)
     1259        0.91596559417721901505460351493
     1260    """
     1261    return RealField_constructor(prec).catalan_constant()
     1262
     1263def py_eval_catalan_for_doctests(prec):
     1264    """
     1265    This function tests py_eval_catalan.
     1266
     1267    EXAMPLES::
     1268
     1269        sage: from sage.symbolic.pynac import py_eval_catalan_for_doctests
     1270        sage: py_eval_catalan_for_doctests(40)
     1271        0.91596559418
     1272    """
     1273    return py_eval_catalan(prec)
     1274   
    10831275cdef public object py_eval_unsigned_infinity():
    10841276    """
    10851277    Returns unsigned_infinity.