Ticket #11143: trac_11143_v2.4.patch

File trac_11143_v2.4.patch, 51.2 KB (added by benjaminfjones, 9 years ago)
  • doc/en/reference/functions.rst

    # HG changeset patch
    # User Benjamin Jones <benjaminfjones@gmail.com>
    # Date 1314069403 25200
    # Node ID 61845fc635d288eedfbe073f095a08896bac05a8
    # Parent  9ab4ab6e12d0ce97566db069205815303514de4d
    Trac 11143: adds top-level access to exponential integral functions in sage/functions/exp_integral.py
    
    diff --git a/doc/en/reference/functions.rst b/doc/en/reference/functions.rst
    a b  
    1111   sage/functions/orthogonal_polys
    1212   sage/functions/other
    1313   sage/functions/special
     14   sage/functions/exp_integral
    1415   sage/functions/wigner
    1516   sage/functions/generalized
    1617   sage/functions/prime_pi
  • sage/functions/all.py

    diff --git a/sage/functions/all.py b/sage/functions/all.py
    a b  
    2424from log import (exp, log, ln, polylog, dilog)
    2525
    2626
    27 from transcendental import (exponential_integral_1,
    28                             zeta, zetaderiv, zeta_symmetric,
    29                             Li, Ei,
    30                             dickman_rho)
     27from transcendental import (zeta, zetaderiv, zeta_symmetric,
     28                            Li, dickman_rho)
    3129
    3230from special import (bessel_I, bessel_J, bessel_K, bessel_Y,
    3331                     hypergeometric_U, Bessel,
     
    3533                     spherical_hankel1, spherical_hankel2,
    3634                     spherical_harmonic, jacobi,
    3735                     inverse_jacobi,
    38                      lngamma, exp_int, error_fcn, elliptic_e,
     36                     lngamma, error_fcn, elliptic_e,
    3937                     elliptic_f, elliptic_ec, elliptic_eu,
    4038                     elliptic_kc, elliptic_pi, elliptic_j,
    4139                     airy_ai, airy_bi)
     
    6462                         kronecker_delta)
    6563
    6664from min_max import max_symbolic, min_symbolic
     65
     66from exp_integral import (exp_integral_e, exp_integral_e1, log_integral, li,
     67                          sin_integral, cos_integral, Si, Ci,
     68                          sinh_integral, cosh_integral, Shi, Chi,
     69                          exponential_integral_1, exp_int, Ei)
  • new file sage/functions/exp_integral.py

    diff --git a/sage/functions/exp_integral.py b/sage/functions/exp_integral.py
    new file mode 100644
    - +  
     1r"""
     2Exponential Integrals
     3
     4AUTHORS:
     5
     6- Benjamin Jones (2011-06-12)
     7
     8This module provides easy access to many exponential integral
     9special functions. It utilizes Maxima's `special functions package`_ and
     10the `mpmath library`_.
     11
     12REFERENCES:
     13
     14- [AS]_ Abramowitz and Stegun: *Handbook of Mathematical Functions*
     15- Wikipedia Entry: http://en.wikipedia.org/wiki/Exponential_integral
     16- Online Encyclopedia of Special Function: http://algo.inria.fr/esf/index.html
     17- NIST Digital Library of Mathematical Functions: http://dlmf.nist.gov/
     18- Maxima `special functions package`_
     19- `mpmath library`_
     20
     21.. [AS] 'Handbook of Mathematical Functions', Milton Abramowitz and Irene
     22   A. Stegun, National Bureau of Standards Applied Mathematics Series, 55.
     23   See also http://www.math.sfu.ca/~cbm/aands/.
     24.. _`special functions package`: http://maxima.sourceforge.net/docs/manual/en/maxima_15.html
     25.. _`mpmath library`: http://code.google.com/p/mpmath/
     26
     27AUTHORS:
     28
     29- Benjamin Jones
     30
     31    Implementations of the classes ``Function_exp_integral_*``.
     32
     33- David Joyner and William Stein
     34
     35    Authors of the code which was moved from special.py and trans.py.
     36    Implementation of :meth:`exp_int` (from sage/functions/special.py).
     37    Implementation of :meth:`exponential_integral_1` (from
     38    sage/functions/transcendental.py).
     39
     40"""
     41
     42#*****************************************************************************
     43#       Copyright (C) 2011 Benjamin Jones <benjaminfjones@gmail.com>
     44#
     45#  Distributed under the terms of the GNU General Public License (GPL)
     46#
     47#    This code is distributed in the hope that it will be useful,
     48#    but WITHOUT ANY WARRANTY; without even the implied warranty of
     49#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     50#    General Public License for more details.
     51#
     52#  The full text of the GPL is available at:
     53#
     54#                  http://www.gnu.org/licenses/
     55#*****************************************************************************
     56
     57import sage.interfaces.all
     58from sage.misc.sage_eval import sage_eval
     59from sage.symbolic.function import BuiltinFunction, is_inexact
     60from sage.calculus.calculus import maxima
     61from sage.symbolic.expression import Expression
     62from sage.structure.parent import Parent
     63from sage.structure.coerce import parent
     64from sage.libs.mpmath import utils as mpmath_utils
     65mpmath_utils_call = mpmath_utils.call # eliminate some overhead in _evalf_
     66
     67from sage.rings.rational_field import RationalField
     68from sage.rings.real_mpfr import RealField
     69from sage.rings.complex_field import ComplexField
     70from sage.rings.all import ZZ, QQ, RR, RDF
     71from sage.functions.log import exp, log
     72from sage.functions.trig import sin, cos
     73from sage.functions.hyperbolic import sinh, cosh
     74
     75
     76class Function_exp_integral_e(BuiltinFunction):
     77    r"""
     78    The generalized complex exponential integral `E_n(z)` defined by
     79
     80    .. math::
     81
     82        \operatorname{E_n}(z) = \int_1^{\infty} \frac{e^{-z t}}{t^n} \; dt
     83
     84    for complex numbers `n` and `z`, see [AS]_ 5.1.4.
     85
     86    The special case where `n = 1` is denoted in Sage by
     87    ``exp_integral_e1``.
     88
     89    EXAMPLES:
     90
     91    Numerical evaluation is handled using mpmath::
     92
     93        sage: N(exp_integral_e(1,1))
     94        0.219383934395520
     95        sage: exp_integral_e(1, RealField(100)(1))
     96        0.21938393439552027367716377546
     97
     98    We can compare this to PARI's evaluation of
     99    :meth:`exponential_integral_1`::
     100
     101        sage: N(exponential_integral_1(1))
     102        0.219383934395520
     103
     104    We can verify one case of [AS]_ 5.1.45, i.e.
     105    `E_n(z) = z^{n-1}\Gamma(1-n,z)`::
     106
     107        sage: N(exp_integral_e(2, 3+I))
     108        0.00354575823814662 - 0.00973200528288687*I
     109        sage: N((3+I)*gamma(-1, 3+I))
     110        0.00354575823814662 - 0.00973200528288687*I
     111
     112    Maxima returns the following improper integral as a multiple of
     113    ``exp_integral_e(1,1)``::
     114
     115        sage: uu = integral(e^(-x)*log(x+1),x,0,oo)
     116        sage: uu
     117        e*exp_integral_e(1, 1)
     118        sage: uu.n(digits=30)
     119        0.596347362323194074341078499369
     120
     121    Symbolic derivatives and integrals are handled by Sage and Maxima::
     122
     123        sage: x = var('x')
     124        sage: f = exp_integral_e(2,x)
     125        sage: f.diff(x)
     126        -exp_integral_e(1, x)
     127
     128        sage: f.integrate(x)
     129        -exp_integral_e(3, x)
     130
     131        sage: f = exp_integral_e(-1,x)
     132        sage: f.integrate(x)
     133        Ei(-x) - gamma(-1, x)
     134
     135    Some special values of ``exp_integral_e`` can be simplified.
     136    [AS]_ 5.1.23::
     137
     138        sage: exp_integral_e(0,x)
     139        e^(-x)/x
     140
     141    [AS]_ 5.1.24::
     142
     143        sage: exp_integral_e(6,0)
     144        1/5
     145        sage: nn = var('nn')
     146        sage: assume(nn > 1)
     147        sage: f = exp_integral_e(nn,0)
     148        sage: f.simplify()
     149        1/(nn - 1)
     150
     151
     152    ALGORITHM:
     153
     154    Numerical evaluation is handled using mpmath, but symbolics are handled
     155    by Sage and Maxima.
     156
     157    """
     158    def __init__(self):
     159        """
     160        See the docstring for :meth:`Function_exp_integral_e`.
     161
     162        EXAMPLES::
     163
     164            sage: exp_integral_e(1,0)
     165            exp_integral_e(1, 0)
     166
     167        """
     168        BuiltinFunction.__init__(self, "exp_integral_e", nargs=2,
     169                                 latex_name=r'exp_integral_e',
     170                                 conversions=dict(maxima='expintegral_e'))
     171
     172    def _eval_(self, n, z):
     173        """
     174        EXAMPLES::
     175
     176            sage: exp_integral_e(1.0, x)
     177            exp_integral_e(1.00000000000000, x)
     178            sage: exp_integral_e(x, 1.0)
     179            exp_integral_e(x, 1.00000000000000)
     180            sage: exp_integral_e(1.0, 1.0)
     181            0.219383934395520
     182
     183        """
     184        if not isinstance(n, Expression) and not isinstance(z, Expression) and \
     185               (is_inexact(n) or is_inexact(z)):
     186            coercion_model = sage.structure.element.get_coercion_model()
     187            n, z = coercion_model.canonical_coercion(n, z)
     188            return self._evalf_(n, z, parent(n))
     189
     190        z_zero = False
     191        # special case: z == 0 and n > 1
     192        if isinstance(z, Expression):
     193            if z.is_trivial_zero():
     194                z_zero = True # for later
     195                if n > 1:
     196                    return 1/(n-1)
     197        else:
     198            if not z:
     199                z_zero = True
     200                if n > 1:
     201                    return 1/(n-1)
     202
     203        # special case: n == 0
     204        if isinstance(n, Expression):
     205            if n.is_trivial_zero():
     206                if z_zero:
     207                    return None
     208                else:
     209                    return exp(-z)/z
     210        else:
     211            if not n:
     212                if z_zero:
     213                    return None
     214                else:
     215                    return exp(-z)/z
     216
     217        return None # leaves the expression unevaluated
     218
     219    def _evalf_(self, n, z, parent=None):
     220        """
     221        EXAMPLES::
     222
     223            sage: N(exp_integral_e(1, 1+I))
     224            0.000281624451981418 - 0.179324535039359*I
     225            sage: exp_integral_e(1, RealField(100)(1))
     226            0.21938393439552027367716377546
     227
     228        """
     229        import mpmath
     230        return mpmath_utils.call(mpmath.expint, n, z, parent=parent)
     231
     232    def _derivative_(self, n, z, diff_param=None):
     233        """
     234        If `n` is an integer strictly larger than 0, then the derivative of
     235        `E_n(z)` with respect to `z` is
     236        `-E_{n-1}(z)`. See [AS]_ 5.1.26.
     237
     238        EXAMPLES::
     239
     240            sage: x = var('x')
     241            sage: f = exp_integral_e(2,x)
     242            sage: f.diff(x)
     243            -exp_integral_e(1, x)
     244
     245            sage: f = exp_integral_e(2,sqrt(x))
     246            sage: f.diff(x)
     247            -1/2*exp_integral_e(1, sqrt(x))/sqrt(x)
     248
     249        """
     250        if n in ZZ and n > 0:
     251            return -1*exp_integral_e(n-1,z)
     252        else:
     253            raise NotImplementedError("The derivative of this function is only implemented for n = 1, 2, 3, ...")
     254
     255exp_integral_e = Function_exp_integral_e()
     256
     257
     258class Function_exp_integral_e1(BuiltinFunction):
     259    r"""
     260    The generalized complex exponential integral `E_1(z)` defined by
     261
     262    .. math::
     263
     264        \operatorname{E_1}(z) = \int_z^\infty \frac{e^{-t}}{t}\; dt
     265
     266    see [AS]_ 5.1.4.
     267
     268    EXAMPLES:
     269
     270    Numerical evaluation is handled using mpmath::
     271
     272        sage: N(exp_integral_e1(1))
     273        0.219383934395520
     274        sage: exp_integral_e1(RealField(100)(1))
     275        0.21938393439552027367716377546
     276
     277    We can compare this to PARI's evaluation of
     278    :meth:`exponential_integral_1`::
     279
     280        sage: N(exp_integral_e1(2.0))
     281        0.0489005107080611
     282        sage: N(exponential_integral_1(2.0))
     283        0.0489005107080611
     284
     285    Symbolic derivatives and integrals are handled by Sage and Maxima::
     286
     287        sage: x = var('x')
     288        sage: f = exp_integral_e1(x)
     289        sage: f.diff(x)
     290        -e^(-x)/x
     291
     292        sage: f.integrate(x)
     293        -exp_integral_e(2, x)
     294
     295    ALGORITHM:
     296
     297    Numerical evaluation is handled using mpmath, but symbolics are handled
     298    by Sage and Maxima.
     299
     300    """
     301    def __init__(self):
     302        """
     303        See the docstring for :class:`Function_exp_integral_e1`.
     304
     305        EXAMPLES::
     306
     307            sage: exp_integral_e1(1)
     308            exp_integral_e1(1)
     309
     310        """
     311        BuiltinFunction.__init__(self, "exp_integral_e1", nargs=1,
     312                                 latex_name=r'exp_integral_e1',
     313                                 conversions=dict(maxima='expintegral_e1'))
     314
     315    def _eval_(self, z):
     316        """
     317        EXAMPLES::
     318
     319            sage: exp_integral_e1(x)
     320            exp_integral_e1(x)
     321            sage: exp_integral_e1(1.0)
     322            0.219383934395520
     323
     324        """
     325        if not isinstance(z, Expression) and is_inexact(z):
     326            return self._evalf_(z, parent(z))
     327
     328        return None # leaves the expression unevaluated
     329
     330    def _evalf_(self, z, parent=None):
     331        """
     332        EXAMPLES::
     333
     334            sage: N(exp_integral_e1(1+I))
     335            0.000281624451981418 - 0.179324535039359*I
     336            sage: exp_integral_e1(RealField(200)(0.5))
     337            0.55977359477616081174679593931508523522684689031635351524829
     338
     339        """
     340        import mpmath
     341        return mpmath_utils_call(mpmath.e1, z, parent=parent)
     342
     343    def _derivative_(self, z, diff_param=None):
     344        """
     345        The derivative of `E_1(z)` is `-e^{-z}/z`. See [AS], 5.1.26.
     346
     347        EXAMPLES::
     348
     349            sage: x = var('x')
     350            sage: f = exp_integral_e1(x)
     351            sage: f.diff(x)
     352            -e^(-x)/x
     353
     354            sage: f = exp_integral_e1(x^2)
     355            sage: f.diff(x)
     356            -2*e^(-x^2)/x
     357
     358        """
     359        return -exp(-z)/z
     360
     361exp_integral_e1 = Function_exp_integral_e1()
     362
     363
     364class Function_log_integral(BuiltinFunction):
     365    r"""
     366    The logarithmic integral `\operatorname{li}(z)` defined by
     367
     368    .. math::
     369
     370        \operatorname{li}(x) = \int_0^z \frac{dt}{\ln(t)} = \operatorname{Ei}(\ln(x))
     371
     372    for x > 1 and by analytic continuation for complex arguments z (see [AS]_ 5.1.3).
     373
     374    EXAMPLES:
     375
     376    Numerical evaluation for real and complex arguments is handled using mpmath::
     377
     378        sage: N(log_integral(3))
     379        2.16358859466719
     380        sage: N(log_integral(3), digits=30)
     381        2.16358859466719197287692236735
     382        sage: log_integral(ComplexField(100)(3+I))
     383        2.2879892769816826157078450911 + 0.87232935488528370139883806779*I
     384
     385    Symbolic derivatives and integrals are handled by Sage and Maxima::
     386
     387        sage: x = var('x')
     388        sage: f = log_integral(x)
     389        sage: f.diff(x)
     390        1/log(x)
     391
     392        sage: f.integrate(x)
     393        x*log_integral(x) - Ei(2*log(x))
     394
     395    Here is a test from the mpmath documentation. There are
     396    1,925,320,391,606,803,968,923 many prime numbers less than 1e23. The
     397    value of ``log_integral(1e23)`` is very close to this::
     398
     399        sage: log_integral(1e23)
     400        1.92532039161405e21
     401
     402    ALGORITHM:
     403
     404    Numerical evaluation is handled using mpmath, but symbolics are handled
     405    by Sage and Maxima.
     406
     407    REFERENCES:
     408
     409    - http://en.wikipedia.org/wiki/Logarithmic_integral_function
     410    - mpmath documentation: `logarithmic-integral`_
     411
     412    .. _`logarithmic-integral`: http://mpmath.googlecode.com/svn/trunk/doc/build/functions/expintegrals.html#logarithmic-integral
     413
     414
     415    """
     416    def __init__(self):
     417        """
     418        See the docstring for ``Function_log_integral``.
     419
     420        EXAMPLES::
     421
     422            sage: log_integral(3)
     423            log_integral(3)
     424
     425        """
     426        BuiltinFunction.__init__(self, "log_integral", nargs=1,
     427                                 latex_name=r'log_integral',
     428                                 conversions=dict(maxima='expintegral_li'))
     429
     430    def _eval_(self, z):
     431        """
     432        EXAMPLES::
     433
     434            sage: z = var('z')
     435            sage: log_integral(z)
     436            log_integral(z)
     437            sage: log_integral(3.0)
     438            2.16358859466719
     439
     440        """
     441        if not isinstance(z, Expression) and is_inexact(z):
     442            return self._evalf_(z, parent(z))
     443
     444        return None # leaves the expression unevaluated
     445
     446    def _evalf_(self, z, parent=None):
     447        """
     448        EXAMPLES::
     449
     450            sage: N(log_integral(1e6))
     451            78627.5491594622
     452            sage: log_integral(RealField(200)(1e6))
     453            78627.549159462181919862910747947261161321874382421767074759
     454
     455        """
     456        import mpmath
     457        return mpmath_utils_call(mpmath.li, z, parent=parent)
     458
     459    def _derivative_(self, z, diff_param=None):
     460        """
     461        The derivative of `\operatorname{li}(z) is `1/log(z)`.
     462
     463        EXAMPLES::
     464
     465            sage: x = var('x')
     466            sage: f = log_integral(x)
     467            sage: f.diff(x)
     468            1/log(x)
     469
     470            sage: f = log_integral(x^2)
     471            sage: f.diff(x)
     472            2*x/log(x^2)
     473
     474        """
     475        return 1/log(z)
     476
     477li = log_integral = Function_log_integral()
     478
     479
     480class Function_sin_integral(BuiltinFunction):
     481    r"""
     482    The trigonometric integral `\operatorname{Si}(z)` defined by
     483
     484    .. math::
     485
     486        \operatorname{Si}(z) = \int_0^z \frac{\sin(t)}{t}\; dt,
     487
     488    see [AS]_ 5.2.1.
     489
     490    EXAMPLES:
     491
     492    Numerical evaluation for real and complex arguments is handled using mpmath::
     493
     494        sage: sin_integral(0)
     495        0
     496        sage: sin_integral(0.0)
     497        0.000000000000000
     498        sage: sin_integral(3.0)
     499        1.84865252799947
     500        sage: N(sin_integral(3), digits=30)
     501        1.84865252799946825639773025111
     502        sage: sin_integral(ComplexField(100)(3+I))
     503        2.0277151656451253616038525998 + 0.015210926166954211913653130271*I
     504
     505    The alias `Si` can be used instead of `sin_integral`::
     506
     507        sage: Si(3.0)
     508        1.84865252799947
     509
     510    The limit of `\operatorname{Si}(z)` as `z \to \infty` is `\pi/2`::
     511
     512        sage: N(sin_integral(1e23))
     513        1.57079632679490
     514        sage: N(pi/2)
     515        1.57079632679490
     516
     517    At 200 bits of precision `\operatorname{Si}(10^{23})` agrees with `\pi/2` up to
     518    `10^{-24}`::
     519
     520        sage: sin_integral(RealField(200)(1e23))
     521        1.5707963267948966192313288218697837425815368604836679189519
     522        sage: N(pi/2, prec=200)
     523        1.5707963267948966192313216916397514420985846996875529104875
     524
     525    The exponential sine integral is analytic everywhere::
     526
     527        sage: sin_integral(-1.0)
     528        -0.946083070367183
     529        sage: sin_integral(-2.0)
     530        -1.60541297680269
     531        sage: sin_integral(-1e23)
     532        -1.57079632679490
     533
     534    Symbolic derivatives and integrals are handled by Sage and Maxima::
     535
     536        sage: x = var('x')
     537        sage: f = sin_integral(x)
     538        sage: f.diff(x)
     539        sin(x)/x
     540
     541        sage: f.integrate(x)
     542        x*sin_integral(x) + cos(x)
     543
     544        sage: integrate(sin(x)/x, x)
     545        1/2*I*Ei(-I*x) - 1/2*I*Ei(I*x)
     546
     547    Compare values of the functions `\operatorname{Si}(x)` and
     548    `f(x) = (1/2)i \cdot \operatorname{Ei}(-ix) - (1/2)i \cdot
     549    \operatorname{Ei}(ix) - \pi/2`, which are both anti-derivatives of
     550    `\sin(x)/x`, at some random positive real numbers::
     551
     552        sage: f(x) = 1/2*I*Ei(-I*x) - 1/2*I*Ei(I*x) - pi/2
     553        sage: g(x) = sin_integral(x)
     554        sage: R = [ abs(RDF.random_element()) for i in range(100) ]
     555        sage: all(abs(f(x) - g(x)) < 1e-10 for x in R)
     556        True
     557
     558    The Nielsen spiral is the parametric plot of (Si(t), Ci(t))::
     559
     560        sage: x=var('x')
     561        sage: f(x) = sin_integral(x)
     562        sage: g(x) = cos_integral(x)
     563        sage: P = parametric_plot([f, g], (x, 0.5 ,20))
     564        sage: show(P, frame=True, axes=False)
     565
     566    ALGORITHM:
     567
     568    Numerical evaluation is handled using mpmath, but symbolics are handled
     569    by Sage and Maxima.
     570
     571    REFERENCES:
     572
     573    - http://en.wikipedia.org/wiki/Trigonometric_integral
     574    - mpmath documentation: `si`_
     575
     576    .. _`si`: http://mpmath.googlecode.com/svn/trunk/doc/build/functions/expintegrals.html#si
     577
     578    """
     579    def __init__(self):
     580        """
     581        See the docstring for ``Function_sin_integral``.
     582
     583        EXAMPLES::
     584
     585            sage: sin_integral(1)
     586            sin_integral(1)
     587
     588        """
     589        BuiltinFunction.__init__(self, "sin_integral", nargs=1,
     590                                 latex_name=r'\operatorname{Si}',
     591                                 conversions=dict(maxima='expintegral_si'))
     592
     593    def _eval_(self, z):
     594        """
     595        EXAMPLES::
     596
     597            sage: z = var('z')
     598            sage: sin_integral(z)
     599            sin_integral(z)
     600            sage: sin_integral(3.0)
     601            1.84865252799947
     602            sage: sin_integral(0)
     603            0
     604
     605        """
     606        if not isinstance(z, Expression) and is_inexact(z):
     607            return self._evalf_(z, parent(z))
     608
     609        # special case: z = 0
     610        if isinstance(z, Expression):
     611            if z.is_trivial_zero():
     612                return z
     613        else:
     614            if not z:
     615                return z
     616
     617        return None # leaves the expression unevaluated
     618
     619    def _evalf_(self, z, parent=None):
     620        """
     621        EXAMPLES:
     622
     623        The limit `\operatorname{Si}(z)` as `z \to \infty`  is `\pi/2`::
     624
     625            sage: N(sin_integral(1e23) - pi/2)
     626            0.000000000000000
     627
     628        At 200 bits of precision `\operatorname{Si}(10^{23})` agrees with `\pi/2` up to
     629        `10^{-24}`::
     630
     631            sage: sin_integral(RealField(200)(1e23))
     632            1.5707963267948966192313288218697837425815368604836679189519
     633            sage: N(pi/2, prec=200)
     634            1.5707963267948966192313216916397514420985846996875529104875
     635
     636        The exponential sine integral is analytic everywhere, even on the
     637        negative real axis::
     638
     639            sage: sin_integral(-1.0)
     640            -0.946083070367183
     641            sage: sin_integral(-2.0)
     642            -1.60541297680269
     643            sage: sin_integral(-1e23)
     644            -1.57079632679490
     645
     646        """
     647        import mpmath
     648        return mpmath_utils_call(mpmath.si, z, parent=parent)
     649
     650    def _derivative_(self, z, diff_param=None):
     651        """
     652        The derivative of `\operatorname{Si}(z)` is `\sin(z)/z` if `z` is not zero. The derivative
     653        at `z = 0` is `1` (but this exception is not currently implimented).
     654
     655        EXAMPLES::
     656
     657            sage: x = var('x')
     658            sage: f = sin_integral(x)
     659            sage: f.diff(x)
     660            sin(x)/x
     661
     662            sage: f = sin_integral(x^2)
     663            sage: f.diff(x)
     664            2*sin(x^2)/x
     665
     666        """
     667        return sin(z)/z
     668
     669Si = sin_integral = Function_sin_integral()
     670
     671
     672class Function_cos_integral(BuiltinFunction):
     673    r"""
     674    The trigonometric integral `\operatorname{Ci}(z)` defined by
     675
     676    .. math::
     677
     678        \operatorname{Ci}(z) = \gamma + \log(z) + \int_0^z \frac{\cos(t)-1}{t}\; dt,
     679
     680    where `\gamma` is the Euler gamma constant (``euler_gamma`` in Sage),
     681    see [AS]_ 5.2.1.
     682
     683    EXAMPLES:
     684
     685    Numerical evaluation for real and complex arguments is handled using mpmath::
     686
     687        sage: cos_integral(3.0)
     688        0.119629786008000
     689
     690    The alias `Ci` can be used instead of `cos_integral`::
     691
     692        sage: Ci(3.0)
     693        0.119629786008000
     694
     695    Compare ``cos_integral(3.0)`` to the definition of the value using
     696    numerical integration::
     697
     698        sage: N(euler_gamma + log(3.0) + integrate((cos(x)-1)/x, x, 0, 3.0) - cos_integral(3.0)) < 1e-14
     699        True
     700
     701    Arbitrary precision and complex arguments are handled::
     702
     703        sage: N(cos_integral(3), digits=30)
     704        0.119629786008000327626472281177
     705        sage: cos_integral(ComplexField(100)(3+I))
     706        0.078134230477495714401983633057 - 0.37814733904787920181190368789*I
     707
     708    The limit `\operatorname{Ci}(z)` as `z \to \infty` is zero::
     709
     710        sage: N(cos_integral(1e23))
     711        -3.24053937643003e-24
     712
     713    Symbolic derivatives and integrals are handled by Sage and Maxima::
     714
     715        sage: x = var('x')
     716        sage: f = cos_integral(x)
     717        sage: f.diff(x)
     718        cos(x)/x
     719
     720        sage: f.integrate(x)
     721        x*cos_integral(x) - sin(x)
     722
     723    The Nielsen spiral is the parametric plot of (Si(t), Ci(t))::
     724
     725        sage: t=var('t')
     726        sage: f(t) = sin_integral(t)
     727        sage: g(t) = cos_integral(t)
     728        sage: P = parametric_plot([f, g], (t, 0.5 ,20))
     729        sage: show(P, frame=True, axes=False)
     730
     731    ALGORITHM:
     732
     733    Numerical evaluation is handled using mpmath, but symbolics are handled
     734    by Sage and Maxima.
     735
     736    REFERENCES:
     737
     738    - http://en.wikipedia.org/wiki/Trigonometric_integral
     739    - mpmath documentation: `ci`_
     740
     741    .. _`ci`: http://mpmath.googlecode.com/svn/trunk/doc/build/functions/expintegrals.html#ci
     742
     743    """
     744    def __init__(self):
     745        """
     746        See the docstring for :class:`Function_cos_integral`.
     747
     748        EXAMPLES::
     749
     750            sage: cos_integral(1)
     751            cos_integral(1)
     752
     753        """
     754        BuiltinFunction.__init__(self, "cos_integral", nargs=1,
     755                                 latex_name=r'\operatorname{Ci}',
     756                                 conversions=dict(maxima='expintegral_ci'))
     757
     758    def _eval_(self, z):
     759        """
     760        EXAMPLES::
     761
     762            sage: z = var('z')
     763            sage: cos_integral(z)
     764            cos_integral(z)
     765            sage: cos_integral(3.0)
     766            0.119629786008000
     767            sage: cos_integral(0)
     768            cos_integral(0)
     769            sage: N(cos_integral(0))
     770            -infinity
     771
     772        """
     773        if not isinstance(z, Expression) and is_inexact(z):
     774            return self._evalf_(z, parent(z))
     775
     776        return None # leaves the expression unevaluated
     777
     778    def _evalf_(self, z, parent=None):
     779        """
     780        EXAMPLES::
     781
     782            sage: N(cos_integral(1e23)) < 1e-20
     783            True
     784            sage: N(cos_integral(1e-10), digits=30)
     785            -22.4486352650389235918737540487
     786            sage: cos_integral(ComplexField(100)(I))
     787            0.83786694098020824089467857943 + 1.5707963267948966192313216916*I
     788
     789        """
     790        import mpmath
     791        return mpmath_utils_call(mpmath.ci, z, parent=parent)
     792
     793    def _derivative_(self, z, diff_param=None):
     794        """
     795        The derivative of `\operatorname{Ci}(z)` is `\cos(z)/z` if `z` is not zero.
     796
     797        EXAMPLES::
     798
     799            sage: x = var('x')
     800            sage: f = cos_integral(x)
     801            sage: f.diff(x)
     802            cos(x)/x
     803
     804            sage: f = cos_integral(x^2)
     805            sage: f.diff(x)
     806            2*cos(x^2)/x
     807
     808        """
     809        return cos(z)/z
     810
     811Ci = cos_integral = Function_cos_integral()
     812
     813
     814class Function_sinh_integral(BuiltinFunction):
     815    r"""
     816    The trigonometric integral `\operatorname{Shi}(z)` defined by
     817
     818    .. math::
     819
     820        \operatorname{Shi}(z) = \int_0^z \frac{\sinh(t)}{t}\; dt,
     821
     822    see [AS]_ 5.2.3.
     823
     824    EXAMPLES:
     825
     826    Numerical evaluation for real and complex arguments is handled using mpmath::
     827
     828        sage: sinh_integral(3.0)
     829        4.97344047585981
     830        sage: sinh_integral(1.0)
     831        1.05725087537573
     832        sage: sinh_integral(-1.0)
     833        -1.05725087537573
     834
     835    The alias `Shi` can be used instead of `sinh_integral`::
     836
     837        sage: Shi(3.0)
     838        4.97344047585981
     839
     840    Compare ``sinh_integral(3.0)`` to the definition of the value using
     841    numerical integration::
     842
     843        sage: N(integrate((sinh(x))/x, x, 0, 3.0) - sinh_integral(3.0)) < 1e-14
     844        True
     845
     846    Arbitrary precision and complex arguments are handled::
     847
     848        sage: N(sinh_integral(3), digits=30)
     849        4.97344047585980679771041838252
     850        sage: sinh_integral(ComplexField(100)(3+I))
     851        3.9134623660329374406788354078 + 3.0427678212908839256360163759*I
     852
     853    The limit `\operatorname{Shi}(z)` as `z \to \infty` is `\infty`::
     854
     855        sage: N(sinh_integral(Infinity))
     856        +infinity
     857
     858    Symbolic derivatives and integrals are handled by Sage and Maxima::
     859
     860        sage: x = var('x')
     861        sage: f = sinh_integral(x)
     862        sage: f.diff(x)
     863        sinh(x)/x
     864
     865        sage: f.integrate(x)
     866        x*sinh_integral(x) - cosh(x)
     867
     868    ALGORITHM:
     869
     870    Numerical evaluation is handled using mpmath, but symbolics are handled
     871    by Sage and Maxima.
     872
     873    REFERENCES:
     874
     875    - http://en.wikipedia.org/wiki/Trigonometric_integral
     876    - mpmath documentation: `shi`_
     877
     878    .. _`shi`: http://mpmath.googlecode.com/svn/trunk/doc/build/functions/expintegrals.html#shi
     879
     880    """
     881    def __init__(self):
     882        """
     883        See the docstring for ``Function_sinh_integral``.
     884
     885        EXAMPLES::
     886
     887            sage: sinh_integral(1)
     888            sinh_integral(1)
     889
     890        """
     891        BuiltinFunction.__init__(self, "sinh_integral", nargs=1,
     892                                 latex_name=r'\operatorname{Shi}',
     893                                 conversions=dict(maxima='expintegral_shi'))
     894
     895    def _eval_(self, z):
     896        """
     897        EXAMPLES::
     898
     899            sage: z = var('z')
     900            sage: sinh_integral(z)
     901            sinh_integral(z)
     902            sage: sinh_integral(3.0)
     903            4.97344047585981
     904            sage: sinh_integral(0)
     905            0
     906
     907        """
     908        if not isinstance(z, Expression) and is_inexact(z):
     909            return self._evalf_(z, parent(z))
     910
     911        # special case: z = 0
     912        if isinstance(z, Expression):
     913            if z.is_trivial_zero():
     914                return z
     915        else:
     916            if not z:
     917                return z
     918
     919        return None # leaves the expression unevaluated
     920
     921    def _evalf_(self, z, parent=None):
     922        """
     923        EXAMPLES::
     924
     925            sage: N(sinh_integral(1e-10), digits=30)
     926            1.00000000000000003643219731550e-10
     927            sage: sinh_integral(ComplexField(100)(I))
     928            0.94608307036718301494135331382*I
     929
     930        """
     931        import mpmath
     932        return mpmath_utils_call(mpmath.shi, z, parent=parent)
     933
     934    def _derivative_(self, z, diff_param=None):
     935        """
     936        The derivative of `\operatorname{Shi}(z)` is `\sinh(z)/z`.
     937
     938        EXAMPLES::
     939
     940            sage: x = var('x')
     941            sage: f = sinh_integral(x)
     942            sage: f.diff(x)
     943            sinh(x)/x
     944
     945            sage: f = sinh_integral(ln(x))
     946            sage: f.diff(x)
     947            sinh(log(x))/(x*log(x))
     948
     949        """
     950        return sinh(z)/z
     951
     952Shi = sinh_integral = Function_sinh_integral()
     953
     954
     955class Function_cosh_integral(BuiltinFunction):
     956    r"""
     957    The trigonometric integral `\operatorname{Chi}(z)` defined by
     958
     959    .. math::
     960
     961        \operatorname{Chi}(z) = \gamma + \log(z) + \int_0^z \frac{\cosh(t)-1}{t}\; dt,
     962
     963    see [AS]_ 5.2.4.
     964
     965    EXAMPLES:
     966
     967    Numerical evaluation for real and complex arguments is handled using mpmath::
     968
     969        sage: cosh_integral(1.0)
     970        0.837866940980208
     971
     972    The alias `Chi` can be used instead of `cosh_integral`::
     973
     974        sage: Chi(1.0)
     975        0.837866940980208
     976
     977    Here is an example from the mpmath documentation::
     978
     979        sage: f(x) = cosh_integral(x)
     980        sage: find_root(f, 0.1, 1.0)
     981        0.5238225713894826
     982
     983    Compare ``cosh_integral(3.0)`` to the definition of the value using
     984    numerical integration::
     985
     986        sage: N(euler_gamma + log(3.0) + integrate((cosh(x)-1)/x, x, 0, 3.0) -
     987        ...     cosh_integral(3.0)) < 1e-14
     988        True
     989
     990    Arbitrary precision and complex arguments are handled::
     991
     992        sage: N(cosh_integral(3), digits=30)
     993        4.96039209476560976029791763669
     994        sage: cosh_integral(ComplexField(100)(3+I))
     995        3.9096723099686417127843516794 + 3.0547519627014217273323873274*I
     996
     997    The limit of `\operatorname{Chi}(z)` as `z \to \infty` is `\infty`::
     998
     999        sage: N(cosh_integral(Infinity))
     1000        +infinity
     1001
     1002    Symbolic derivatives and integrals are handled by Sage and Maxima::
     1003
     1004        sage: x = var('x')
     1005        sage: f = cosh_integral(x)
     1006        sage: f.diff(x)
     1007        cosh(x)/x
     1008
     1009        sage: f.integrate(x)
     1010        x*cosh_integral(x) - sinh(x)
     1011
     1012    ALGORITHM:
     1013
     1014    Numerical evaluation is handled using mpmath, but symbolics are handled
     1015    by Sage and Maxima.
     1016
     1017    REFERENCES:
     1018
     1019    - http://en.wikipedia.org/wiki/Trigonometric_integral
     1020    - mpmath documentation: `chi`_
     1021
     1022    .. _`chi`: http://mpmath.googlecode.com/svn/trunk/doc/build/functions/expintegrals.html#chi
     1023
     1024    """
     1025    def __init__(self):
     1026        """
     1027        See the docstring for ``Function_cosh_integral``.
     1028
     1029        EXAMPLES::
     1030
     1031            sage: cosh_integral(1)
     1032            cosh_integral(1)
     1033
     1034        """
     1035        BuiltinFunction.__init__(self, "cosh_integral", nargs=1,
     1036                                 latex_name=r'\operatorname{Chi}',
     1037                                 conversions=dict(maxima='expintegral_chi'))
     1038
     1039    def _eval_(self, z):
     1040        """
     1041        EXAMPLES::
     1042
     1043            sage: z = var('z')
     1044            sage: cosh_integral(z)
     1045            cosh_integral(z)
     1046            sage: cosh_integral(3.0)
     1047            4.96039209476561
     1048
     1049        """
     1050        if not isinstance(z, Expression) and is_inexact(z):
     1051            return self._evalf_(z, parent(z))
     1052
     1053        return None
     1054
     1055    def _evalf_(self, z, parent=None):
     1056        """
     1057        EXAMPLES::
     1058
     1059            sage: N(cosh_integral(1e-10), digits=30)
     1060            -22.4486352650389235918737540487
     1061            sage: cosh_integral(ComplexField(100)(I))
     1062            0.33740392290096813466264620389 + 1.5707963267948966192313216916*I
     1063
     1064        """
     1065        import mpmath
     1066        return mpmath_utils_call(mpmath.chi, z, parent=parent)
     1067
     1068    def _derivative_(self, z, diff_param=None):
     1069        """
     1070        The derivative of `\operatorname{Chi}(z)` is `\cosh(z)/z`.
     1071
     1072        EXAMPLES::
     1073
     1074            sage: x = var('x')
     1075            sage: f = cosh_integral(x)
     1076            sage: f.diff(x)
     1077            cosh(x)/x
     1078
     1079            sage: f = cosh_integral(ln(x))
     1080            sage: f.diff(x)
     1081            cosh(log(x))/(x*log(x))
     1082
     1083        """
     1084        return cosh(z)/z
     1085
     1086Chi = cosh_integral = Function_cosh_integral()
     1087
     1088
     1089#############################################
     1090## Code below here was moved from either:
     1091## - sage/functions/transcendental.py
     1092## - sage/functions/special.py
     1093## This occured as part of Trac #11143.
     1094#############################################
     1095
     1096# moved here from sage/functions/special.py
     1097def exp_int(t):
     1098    r"""
     1099    The exponential integral `\int_t^\infty e^{-x}/x \; dx` (`t`
     1100    belongs to `\mathbb{R}`).  This function is deprecated - please use
     1101    ``Ei`` or ``exponential_integral_1`` as needed instead.
     1102
     1103    EXAMPLES::
     1104
     1105        sage: exp_int(6)
     1106        doctest:...: DeprecationWarning: The method exp_int() is deprecated. Use -Ei(-x) or exponential_integral_1(x) as needed instead.
     1107        0.000360082452162659
     1108    """
     1109    from sage.misc.misc import deprecation
     1110    deprecation("The method exp_int() is deprecated. Use -Ei(-x) or exponential_integral_1(x) as needed instead.")
     1111    try:
     1112        return t.eint1()
     1113    except AttributeError:
     1114        from sage.libs.pari.all import pari
     1115        try:
     1116            return pari(t).eint1()
     1117        except:
     1118            raise NotImplementedError
     1119
     1120# moved here from sage/functions/transcendental.py
     1121#
     1122# This class has a name which is not specific enough
     1123# see Function_exp_integral_e above, for example, which
     1124# is the "generalized" exponential integral function. We
     1125# are leaving the name the same for backwards compatibility
     1126# purposes.
     1127class Function_exp_integral(BuiltinFunction):
     1128    r"""
     1129    The generalized complex exponential integral Ei(z) defined by
     1130
     1131    .. math::
     1132
     1133        \operatorname{Ei}(x) = \int_{-\infty}^x \frac{e^t}{t}\; dt
     1134
     1135    for x > 0 and for complex arguments by analytic continuation,
     1136    see [AS]_ 5.1.2.
     1137
     1138    EXAMPLES::
     1139
     1140        sage: Ei(10)
     1141        Ei(10)
     1142        sage: Ei(I)
     1143        Ei(I)
     1144        sage: Ei(3+I)
     1145        Ei(I + 3)
     1146        sage: Ei(1.3)
     1147        2.72139888023202
     1148
     1149    The branch cut for this function is along the negative real axis::
     1150
     1151        sage: Ei(-3 + 0.1*I)
     1152        -0.0129379427181693 + 3.13993830250942*I
     1153        sage: Ei(-3 - 0.1*I)
     1154        -0.0129379427181693 - 3.13993830250942*I
     1155
     1156    ALGORITHM: Uses mpmath.
     1157
     1158    """
     1159    def __init__(self):
     1160        """
     1161        Return the value of the complex exponential integral Ei(z) at a
     1162        complex number z.
     1163
     1164        EXAMPLES::
     1165
     1166            sage: Ei(10)
     1167            Ei(10)
     1168            sage: Ei(I)
     1169            Ei(I)
     1170            sage: Ei(3+I)
     1171            Ei(I + 3)
     1172            sage: Ei(1.3)
     1173            2.72139888023202
     1174
     1175        The branch cut for this function is along the negative real axis::
     1176
     1177            sage: Ei(-3 + 0.1*I)
     1178            -0.0129379427181693 + 3.13993830250942*I
     1179            sage: Ei(-3 - 0.1*I)
     1180            -0.0129379427181693 - 3.13993830250942*I
     1181
     1182        ALGORITHM: Uses mpmath.
     1183        """
     1184        BuiltinFunction.__init__(self, "Ei",
     1185                                 conversions=dict(maxima='expintegral_ei'))
     1186
     1187    def _eval_(self, x ):
     1188        """
     1189        EXAMPLES::
     1190
     1191            sage: Ei(10)
     1192            Ei(10)
     1193            sage: Ei(I)
     1194            Ei(I)
     1195            sage: Ei(1.3)
     1196            2.72139888023202
     1197            sage: Ei(10r)
     1198            Ei(10)
     1199            sage: Ei(1.3r)
     1200            2.7213988802320235
     1201        """
     1202        if not isinstance(x, Expression) and is_inexact(x):
     1203            return self._evalf_(x, parent(x))
     1204        return None
     1205
     1206    def _evalf_(self, x, parent=None):
     1207        """
     1208        EXAMPLES::
     1209
     1210            sage: Ei(10).n()
     1211            2492.22897624188
     1212            sage: Ei(20).n()
     1213            2.56156526640566e7
     1214            sage: Ei(I).n()
     1215            0.337403922900968 + 2.51687939716208*I
     1216            sage: Ei(3+I).n()
     1217            7.82313467600158 + 6.09751978399231*I
     1218        """
     1219        import mpmath
     1220        return mpmath_utils_call(mpmath.ei, x, parent=parent)
     1221
     1222    def __call__(self, x, prec=None, coerce=True, hold=False ):
     1223        """
     1224        Note that the ``prec`` argument is deprecated. The precision for
     1225        the result is deduced from the precision of the input. Convert
     1226        the input to a higher precision explicitly if a result with higher
     1227        precision is desired.
     1228
     1229        EXAMPLES::
     1230
     1231            sage: t = Ei(RealField(100)(2.5)); t
     1232            7.0737658945786007119235519625
     1233            sage: t.prec()
     1234            100
     1235
     1236            sage: Ei(1.1, prec=300)
     1237            doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.
     1238            2.16737827956340306615064476647912607220394065907142504328679588538509331805598360907980986
     1239        """
     1240        if prec is not None:
     1241            from sage.misc.misc import deprecation
     1242            deprecation("The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.")
     1243
     1244            import mpmath
     1245            return mpmath_utils_call(mpmath.ei, x, prec=prec)
     1246
     1247        return BuiltinFunction.__call__(self, x, coerce=coerce, hold=hold)
     1248
     1249    def _derivative_(self, x, diff_param=None):
     1250        """
     1251        EXAMPLES::
     1252
     1253            sage: Ei(x).diff(x)
     1254            e^x/x
     1255            sage: Ei(x).diff(x).subs(x=1)
     1256            e
     1257            sage: Ei(x^2).diff(x)
     1258            2*e^(x^2)/x
     1259            sage: f = function('f')
     1260            sage: Ei(f(x)).diff(x)
     1261            e^f(x)*D[0](f)(x)/f(x)
     1262        """
     1263        return exp(x)/x
     1264
     1265Ei = exp_integral_ei = Function_exp_integral()
     1266
     1267
     1268# moved here from sage/functions/transcendental.py
     1269def exponential_integral_1(x, n=0):
     1270    r"""
     1271    Returns the exponential integral `E_1(x)`. If the optional
     1272    argument `n` is given, computes list of the first
     1273    `n` values of the exponential integral
     1274    `E_1(x m)`.
     1275
     1276    The exponential integral `E_1(x)` is
     1277
     1278    .. math::
     1279
     1280                      E_1(x) = \int_{x}^{\infty} e^{-t}/t dt
     1281
     1282
     1283
     1284    INPUT:
     1285
     1286
     1287    -  ``x`` - a positive real number
     1288
     1289    -  ``n`` - (default: 0) a nonnegative integer; if
     1290       nonzero, then return a list of values E_1(x\*m) for m =
     1291       1,2,3,...,n. This is useful, e.g., when computing derivatives of
     1292       L-functions.
     1293
     1294
     1295    OUTPUT:
     1296
     1297
     1298    -  ``float`` - if n is 0 (the default) or
     1299
     1300    -  ``list`` - list of floats if n 0
     1301
     1302
     1303    EXAMPLES::
     1304
     1305        sage: exponential_integral_1(2)
     1306        0.04890051070806112
     1307        sage: w = exponential_integral_1(2,4); w
     1308        [0.04890051070806112, 0.0037793524098489067, 0.00036008245216265873, 3.7665622843924751e-05] # 32-bit
     1309        [0.04890051070806112, 0.0037793524098489063, 0.00036008245216265873, 3.7665622843924534e-05] # 64-bit
     1310
     1311    IMPLEMENTATION: We use the PARI C-library functions eint1 and
     1312    veceint1.
     1313
     1314    REFERENCE:
     1315
     1316    - See page 262, Prop 5.6.12, of Cohen's book "A Course in
     1317      Computational Algebraic Number Theory".
     1318
     1319    REMARKS: When called with the optional argument n, the PARI
     1320    C-library is fast for values of n up to some bound, then very very
     1321    slow. For example, if x=5, then the computation takes less than a
     1322    second for n=800000, and takes "forever" for n=900000.
     1323    """
     1324    if isinstance(x, Expression):
     1325        raise NotImplementedError("Use the symbolic exponential integral " +
     1326        "function: exp_integral_e1.")
     1327    from sage.libs.pari.all import pari
     1328    if n <= 0:
     1329        return float(pari(x).eint1())
     1330    else:
     1331        return [float(z) for z in pari(x).eint1(n)]
  • sage/functions/other.py

    diff --git a/sage/functions/other.py b/sage/functions/other.py
    a b  
    2020from sage.symbolic.function import is_inexact
    2121from sage.functions.log import exp
    2222from sage.functions.trig import arctan2
    23 from sage.functions.transcendental import Ei
     23from sage.functions.exp_integral import Ei
    2424from sage.libs.mpmath import utils as mpmath_utils
    2525
    2626one_half = ~SR(2)
  • sage/functions/special.py

    diff --git a/sage/functions/special.py b/sage/functions/special.py
    a b  
    16881688    deprecation("The method lngamma() is deprecated. Use log_gamma() instead.")
    16891689    return log_gamma(t)
    16901690
    1691 def exp_int(t):
    1692     r"""
    1693     The exponential integral `\int_t^\infty e^{-x}/x dx` (t
    1694     belongs to RR).  This function is deprecated - please use
    1695     ``Ei`` or ``exponential_integral_1`` as needed instead.
    1696 
    1697     EXAMPLES::
    1698        
    1699         sage: exp_int(6)
    1700         doctest:...: DeprecationWarning: The method exp_int() is deprecated. Use -Ei(-x) or exponential_integral_1(x) as needed instead.
    1701         0.000360082452162659
    1702     """
    1703     from sage.misc.misc import deprecation
    1704     deprecation("The method exp_int() is deprecated. Use -Ei(-x) or exponential_integral_1(x) as needed instead.")
    1705     try:
    1706         return t.eint1()
    1707     except AttributeError:
    1708         from sage.libs.pari.all import pari
    1709         try:
    1710             return pari(t).eint1()
    1711         except:
    1712             raise NotImplementedError
    1713 
    17141691def error_fcn(t):
    17151692    r"""
    17161693    The complementary error function
  • sage/functions/transcendental.py

    diff --git a/sage/functions/transcendental.py b/sage/functions/transcendental.py
    a b  
    1818#*****************************************************************************
    1919
    2020import sys
    21 from sage.libs.mpmath import utils as mpmath_utils
    2221import  sage.libs.pari.all
    2322from sage.libs.pari.all import pari
    2423import sage.rings.complex_field as complex_field
     
    3938CC = complex_field.ComplexField()
    4039I = CC.gen(0)
    4140
    42 def exponential_integral_1(x, n=0):
    43     r"""
    44     Returns the exponential integral `E_1(x)`. If the optional
    45     argument `n` is given, computes list of the first
    46     `n` values of the exponential integral
    47     `E_1(x m)`.
    48    
    49     The exponential integral `E_1(x)` is
    50    
    51     .. math::
    52    
    53                       E_1(x) = \int_{x}^{\infty} e^{-t}/t dt     
    54    
    55    
    56    
    57     INPUT:
    58    
    59    
    60     -  ``x`` - a positive real number
    61    
    62     -  ``n`` - (default: 0) a nonnegative integer; if
    63        nonzero, then return a list of values E_1(x\*m) for m =
    64        1,2,3,...,n. This is useful, e.g., when computing derivatives of
    65        L-functions.
    66    
    67    
    68     OUTPUT:
    69    
    70    
    71     -  ``float`` - if n is 0 (the default) or
    72    
    73     -  ``list`` - list of floats if n 0
    74    
    75    
    76     EXAMPLES::
    77    
    78         sage: exponential_integral_1(2)
    79         0.04890051070806112
    80         sage: w = exponential_integral_1(2,4); w
    81         [0.04890051070806112, 0.003779352409848906..., 0.00036008245216265873, 3.7665622843924...e-05]
    82    
    83     IMPLEMENTATION: We use the PARI C-library functions eint1 and
    84     veceint1.
    85    
    86     REFERENCE:
    87 
    88     - See page 262, Prop 5.6.12, of Cohen's book "A Course in
    89       Computational Algebraic Number Theory".
    90    
    91     REMARKS: When called with the optional argument n, the PARI
    92     C-library is fast for values of n up to some bound, then very very
    93     slow. For example, if x=5, then the computation takes less than a
    94     second for n=800000, and takes "forever" for n=900000.
    95     """
    96     if n <= 0:
    97         return float(pari(x).eint1())
    98     else:
    99         return [float(z) for z in pari(x).eint1(n)]
    100 
    10141
    10242class Function_zeta(GinacFunction):
    10343    def __init__(self):
     
    241181    return (s/2 + 1).gamma()   *    (s-1)   * (R.pi()**(-s/2))  *  s.zeta()
    242182
    243183
    244 ##     # Use PARI on complex nubmer
    245 ##     prec = s.prec()
    246 ##     s = pari.new_with_bits_prec(s, prec)
    247 ##     pi = pari.pi()
    248 ##     w = (s/2 + 1).gamma() * (s-1) * pi **(-s/2) * s.zeta()
    249 ##     z = w._sage_()
    250 ##     if z.prec() < prec:
    251 ##         raise RuntimeError, "Error computing zeta_symmetric(%s) -- precision loss."%s
    252 ##     return z
    253 
    254 
    255 #def pi_approx(prec=53):
    256 #    """
    257 #    Return pi computed to prec bits of precision.
    258 #    """
    259 #   return real_field.RealField(prec).pi()
    260 
    261 
    262 class Function_exp_integral(BuiltinFunction):
    263     def __init__(self):
    264         """
    265         Return the value of the complex exponential integral Ei(z) at a
    266         complex number z.
    267        
    268         EXAMPLES::
    269 
    270             sage: Ei(10)
    271             Ei(10)
    272             sage: Ei(I)
    273             Ei(I)
    274             sage: Ei(3+I)
    275             Ei(I + 3)
    276             sage: Ei(1.3)
    277             2.72139888023202
    278            
    279         The branch cut for this function is along the negative real axis::
    280    
    281             sage: Ei(-3 + 0.1*I)
    282             -0.0129379427181693 + 3.13993830250942*I
    283             sage: Ei(-3 - 0.1*I)
    284             -0.0129379427181693 - 3.13993830250942*I
    285    
    286         ALGORITHM: Uses mpmath.
    287         """
    288         BuiltinFunction.__init__(self, "Ei")
    289 
    290     def _eval_(self, x ):
    291         """
    292         EXAMPLES::
    293 
    294             sage: Ei(10)
    295             Ei(10)
    296             sage: Ei(I)
    297             Ei(I)
    298             sage: Ei(1.3)
    299             2.72139888023202
    300             sage: Ei(10r)
    301             Ei(10)
    302             sage: Ei(1.3r)
    303             2.72139888023202
    304         """
    305         if not isinstance(x, Expression) and is_inexact(x):
    306             return self._evalf_(x, parent(x))
    307         return None
    308            
    309     def _evalf_(self, x, parent=None):
    310         """
    311         EXAMPLES::
    312 
    313             sage: Ei(10).n()
    314             2492.22897624188
    315             sage: Ei(20).n()
    316             2.56156526640566e7
    317             sage: Ei(I).n()
    318             0.337403922900968 + 2.51687939716208*I
    319             sage: Ei(3+I).n()
    320             7.82313467600158 + 6.09751978399231*I
    321         """
    322         import mpmath
    323         if isinstance(parent, Parent) and hasattr(parent, 'prec'):
    324             prec = parent.prec()
    325         else:
    326             prec = 53
    327         return mpmath_utils.call(mpmath.ei, x, prec=prec)
    328 
    329     def __call__(self, x, prec=None, coerce=True, hold=False ):
    330         """
    331         Note that the ``prec`` argument is deprecated. The precision for
    332         the result is deduced from the precision of the input. Convert
    333         the input to a higher precision explicitly if a result with higher
    334         precision is desired.
    335 
    336         EXAMPLES::
    337 
    338             sage: t = Ei(RealField(100)(2.5)); t
    339             7.0737658945786007119235519625
    340             sage: t.prec()
    341             100
    342 
    343             sage: Ei(1.1, prec=300)
    344             doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.
    345             2.16737827956340306615064476647912607220394065907142504328679588538509331805598360907980986
    346         """
    347         if prec is not None:
    348             from sage.misc.misc import deprecation
    349             deprecation("The prec keyword argument is deprecated. Explicitly set the precision of the input, for example Ei(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., Ei(1).n(300), instead.")
    350            
    351             import mpmath
    352             return mpmath_utils.call(mpmath.ei, x, prec=prec)
    353 
    354         return BuiltinFunction.__call__(self, x, coerce=coerce, hold=hold)
    355 
    356     def _derivative_(self, x, diff_param=None):
    357         """
    358         EXAMPLES::
    359        
    360             sage: Ei(x).diff(x)
    361             e^x/x
    362             sage: Ei(x).diff(x).subs(x=1)
    363             e
    364             sage: Ei(x^2).diff(x)
    365             2*e^(x^2)/x
    366             sage: f = function('f')
    367             sage: Ei(f(x)).diff(x)
    368             e^f(x)*D[0](f)(x)/f(x)
    369         """
    370         return exp(x)/x
    371 
    372 Ei = Function_exp_integral()
    373 
    374 
    375184def Li(x, eps_rel=None, err_bound=False):
    376185    r"""
    377186    Return value of the function Li(x) as a real double field element.
  • sage/interfaces/maxima_lib.py

    diff --git a/sage/interfaces/maxima_lib.py b/sage/interfaces/maxima_lib.py
    a b  
    13551355    sage.functions.log.polylog : lambda N,X : [[mqapply],[[max_li, max_array],N],X],
    13561356    sage.functions.other.psi1 : lambda X : [[mqapply],[[max_psi, max_array],0],X],
    13571357    sage.functions.other.psi2 : lambda N,X : [[mqapply],[[max_psi, max_array],N],X],
    1358     sage.functions.other.Ei : lambda X : [[max_gamma_incomplete], 0, X]
     1358    sage.functions.exp_integral.Ei : lambda X : [[max_gamma_incomplete], 0, X]
    13591359}
    13601360
    13611361
  • sage/misc/sagedoc.py

    diff --git a/sage/misc/sagedoc.py b/sage/misc/sagedoc.py
    a b  
    878878    ``search_src(string, interact=False).splitlines()`` gives the
    879879    number of matches. ::
    880880
    881         sage: len(search_src('log', 'derivative', interact=False).splitlines()) < 8
     881        sage: len(search_src('log', 'derivative', interact=False).splitlines()) < 9
    882882        True
    883883        sage: len(search_src('log', 'derivative', interact=False, multiline=True).splitlines()) > 30
    884884        True
     
    900900        misc/sagedoc.py:... s = search_src('Matrix', path_re='matrix', interact=False); s.find('x') > 0
    901901        misc/sagedoc.py:... s = search_src('MatRiX', path_re='matrix', interact=False); s.find('x') > 0
    902902        misc/sagedoc.py:... s = search_src('MatRiX', path_re='matrix', interact=False, ignore_case=True); s.find('x') > 0
    903         misc/sagedoc.py:... len(search_src('log', 'derivative', interact=False).splitlines()) < 8
     903        misc/sagedoc.py:... len(search_src('log', 'derivative', interact=False).splitlines()) < 9
    904904        misc/sagedoc.py:... len(search_src('log', 'derivative', interact=False, multiline=True).splitlines()) > 30
    905905        misc/sagedoc.py:... print search_src('^ *sage[:] .*search_src\(', interact=False) # long time
    906906        misc/sagedoc.py:... len(search_src("matrix", interact=False).splitlines()) > 9000 # long time
  • sage/schemes/elliptic_curves/lseries_ell.py

    diff --git a/sage/schemes/elliptic_curves/lseries_ell.py b/sage/schemes/elliptic_curves/lseries_ell.py
    a b  
    99    RationalField,
    1010    ComplexField)
    1111from math import sqrt, exp, ceil
    12 import sage.functions.transcendental as transcendental
     12import sage.functions.exp_integral as exp_integral
    1313R = RealField()
    1414Q = RationalField()
    1515C = ComplexField()
     
    471471        an = self.__E.anlist(k)           # list of Sage Integers
    472472        # Compute z = e^(-2pi/sqrt(N))
    473473        pi = 3.14159265358979323846
    474         v = transcendental.exponential_integral_1(2*pi/sqrtN, k)
     474        v = exp_integral.exponential_integral_1(2*pi/sqrtN, k)
    475475        L = 2*float(sum([ (v[n-1] * an[n])/n for n in xrange(1,k+1)]))
    476476        error = 2*exp(-2*pi*(k+1)/sqrtN)/(1-exp(-2*pi/sqrtN))
    477477        return R(L), R(error)