Ticket #13001: trac_13001.patch

File trac_13001.patch, 4.8 KB (added by benjaminfjones, 9 years ago)

rebase documentation improvements from #1173 to sage-5.0

  • sage/functions/other.py

    # HG changeset patch
    # User Benjamin Jones <benjaminfjones@gmail.com>
    # Date 1337914473 18000
    # Node ID f370e21f7ae1ff66bd03da3e0553bb915bdd0240
    # Parent  c1774fe9f2a85028e24eed776b320d4263ce5ade
    Trac 13001: rebase documentation improvements from #1173 to sage-5.0
    
    diff --git a/sage/functions/other.py b/sage/functions/other.py
    a b  
    2626one_half = ~SR(2)
    2727
    2828class Function_erf(BuiltinFunction):
     29    r"""
     30    The error function, defined for real values as
     31
     32    `\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} dt`.
     33
     34    This function is also defined for complex values, via analytic
     35    continuation.
     36
     37
     38    EXAMPLES:
     39
     40    We can evaluate numerically::
     41
     42        sage: erf(2)
     43        erf(2)
     44        sage: erf(2).n()
     45        0.995322265018953
     46        sage: erf(2).n(100)
     47        0.99532226501895273416206925637
     48        sage: erf(ComplexField(100)(2+3j))
     49        -20.829461427614568389103088452 + 8.6873182714701631444280787545*I
     50
     51    Basic symbolic properties are handled by Sage and Maxima::
     52
     53        sage: x = var("x")
     54        sage: diff(erf(x),x)
     55        2*e^(-x^2)/sqrt(pi)
     56        sage: integrate(erf(x),x)
     57        x*erf(x) + e^(-x^2)/sqrt(pi)
     58
     59    ALGORITHM:
     60
     61    Sage implements numerical evaluation of the error function via the ``erfc()``
     62    function in PARI. Symbolics are handled by Sage and Maxima.
     63
     64    REFERENCES:
     65
     66    - http://en.wikipedia.org/wiki/Error_function
     67
     68    TESTS:
     69
     70    Check limits::
     71
     72        sage: limit(erf(x),x=0)
     73        0
     74        sage: limit(erf(x),x=infinity)
     75        1
     76
     77     Check that it's odd::
     78
     79         sage: erf(1.0)
     80         0.842700792949715
     81         sage: erf(-1.0)
     82         -0.842700792949715
     83
     84    Check against other implementations and against the definition::
     85
     86        sage: erf(3).n()
     87        0.999977909503001
     88        sage: maxima.erf(3).n()
     89        0.999977909503001
     90        sage: (1-pari(3).erfc())
     91        0.999977909503001
     92        sage: RR(3).erf()
     93        0.999977909503001
     94        sage: (integrate(exp(-x**2),(x,0,3))*2/sqrt(pi)).n()
     95        0.999977909503001
     96
     97    Trac #9044::
     98
     99        sage: N(erf(sqrt(2)),200)
     100        0.95449973610364158559943472566693312505644755259664313203267
     101
     102    Trac #11626::
     103
     104        sage: n(erf(2),100)
     105        0.99532226501895273416206925637
     106        sage: erf(2).n(100)
     107        0.99532226501895273416206925637
     108
     109    Test (indirectly) trac #11885::
     110
     111        sage: erf(float(0.5))
     112        0.5204998778130465
     113        sage: erf(complex(0.5))
     114        (0.5204998778130465+0j)
     115
     116    Ensure conversion from maxima elements works::
     117
     118        sage: merf = maxima(erf(x)).sage().operator()
     119        sage: merf == erf
     120        True
     121
     122    Make sure we can dump and load it::
     123
     124        sage: loads(dumps(erf(2)))
     125        erf(2)
     126
     127    Special-case 0 for immediate evaluation::
     128
     129        sage: erf(0)
     130        0
     131        sage: solve(erf(x)==0,x)
     132        [x == 0]
     133
     134    Make sure that we can hold::
     135
     136        sage: erf(0,hold=True)
     137        erf(0)
     138        sage: simplify(erf(0,hold=True))
     139        0
     140
     141    Check that high-precision ComplexField inputs work::
     142
     143        sage: CC(erf(ComplexField(1000)(2+3j)))
     144        -20.8294614276146 + 8.68731827147016*I
     145    """
     146
    29147    def __init__(self):
    30148        r"""
    31         The error function, defined for real values as
    32         `\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} dt`.
    33         This function is also defined for complex values, via analytic
    34         continuation.
     149        See docstring for :meth:`Function_erf`.
    35150
    36         Sage implements the error function via the ``erfc()`` function in PARI.
    37 
    38         EXAMPLES:
    39 
    40         We can evaluate the error function at varying precisions::
     151        EXAMPLES::
    41152
    42153            sage: erf(2)
    43154            erf(2)
    44             sage: erf(2).n()
    45             0.995322265018953
    46             sage: erf(2).n(200)
    47             0.99532226501895273416206925636725292861089179704006007673835
    48 
    49         Complex values can be evaluated as well::
    50 
    51             sage: erf(3*I).n()
    52             1.00000000000000 + 1629.86732385786*I
    53 
    54         Sage simplifies erf(0) automatically::
    55 
    56             sage: erf(0)
    57             0
    58             sage: solve(erf(x)==0,x)
    59             [x == 0]
    60 
    61         TESTS:
    62 
    63         Test pickling::
    64 
    65             sage: loads(dumps(erf))
    66             erf
    67 
    68         Check if conversion from maxima elements work::
    69 
    70             sage: merf = maxima(erf(x)).sage().operator()
    71             sage: merf == erf
    72             True
    73155        """
    74156        BuiltinFunction.__init__(self, "erf", latex_name=r"\text{erf}")
    75157
     
    134216        except AttributeError: # not a Sage parent
    135217            prec = 0
    136218        return parent(1) - parent(pari(x).erfc(prec))
    137        
     219
    138220    def _derivative_(self, x, diff_param=None):
    139221        """
    140222        Derivative of erf function