Ticket #15095: trac15095.patch

sage/combinat/combinat.py

@@ -2131 +2131 @@
                 yield c
             i+=1
 
-
-
-def hurwitz_zeta(s,x,N):
-    """
-    Returns the value of the `\zeta(s,x)` to `N`
-    decimals, where s and x are real.
-
-    The Hurwitz zeta function is one of the many zeta functions. It
-    defined as
-
-    .. math::
-
-             \zeta(s,x) = \sum_{k=0}^\infty (k+x)^{-s}.
-
-
-    When `x = 1`, this coincides with Riemann's zeta function.
-    The Dirichlet L-functions may be expressed as a linear combination
-    of Hurwitz zeta functions.
-
-    Note that if you use floating point inputs, then the results may be
-    slightly off.
-
-    EXAMPLES::
-
-        sage: hurwitz_zeta(3,1/2,6)
-        8.41439000000000
-        sage: hurwitz_zeta(11/10,1/2,6)
-        12.1041000000000
-        sage: hurwitz_zeta(11/10,1/2,50)
-        12.10381349568375510570907741296668061903364861809
-
-    REFERENCES:
-
-    - http://en.wikipedia.org/wiki/Hurwitz_zeta_function
-    """
-    maxima.eval('load ("bffac")')
-    s = maxima.eval("bfhzeta (%s,%s,%s)"%(s,x,N))
-
-    #Handle the case where there is a 'b' in the string
-    #'1.2000b0' means 1.2000 and
-    #'1.2000b1' means 12.000
-    i = s.rfind('b')
-    if i == -1:
-        return sage_eval(s)
-    else:
-        if s[i+1:] == '0':
-            return sage_eval(s[:i])
-        else:
-            return sage_eval(s[:i])*10**sage_eval(s[i+1:])
-
-    return s  ## returns an odd string
-
-
 #####################################################
 #### combinatorial sets/lists
 

sage/functions/all.py

@@ -24 +24 @@
 from log import (exp, log, ln, polylog, dilog, lambert_w)
 
 
-from transcendental import (zeta, zetaderiv, zeta_symmetric, dickman_rho)
+from transcendental import (zeta, zetaderiv, zeta_symmetric, hurwitz_zeta,
+                            dickman_rho)
 
 from sage.functions.bessel import (bessel_I, bessel_J, bessel_K, bessel_Y, Bessel)
 

sage/functions/transcendental.py

@@ -25 +25 @@
 from sage.gsl.integration import numerical_integral
 from sage.structure.parent import Parent
 from sage.structure.coerce import parent
+from sage.structure.element import get_coercion_model
 from sage.symbolic.expression import Expression
 from sage.functions.log import exp
 
@@ -33 +34 @@
                             ZZ, RR, RDF, CDF, prime_range)
 
 from sage.symbolic.function import GinacFunction, BuiltinFunction, is_inexact
-
+import sage.libs.mpmath.utils as mpmath_utils
+from sage.misc.superseded import deprecation
+from sage.rings.infinity import unsigned_infinity
+from sage.functions.other import factorial, psi
+from sage.combinat.combinat import bernoulli_polynomial
 
 CC = complex_field.ComplexField()
 I = CC.gen(0)
@@ -97 +102 @@
 
 zeta = Function_zeta()
 
+
+class Function_HurwitzZeta(BuiltinFunction):
+    def __init__(self):
+        r"""
+        TESTS::
+
+            sage: latex(hurwitz_zeta(x, 2))
+            \zeta\left(x, 2\right)
+            sage: hurwitz_zeta(x, 2)._sympy_()
+            zeta(x, 2)
+        """
+        BuiltinFunction.__init__(self, 'hurwitz_zeta', nargs=2,
+                                 conversions=dict(mathematica='HurwitzZeta',
+                                                  sympy='zeta'),
+                                 latex_name='\zeta')
+
+    def _eval_(self, s, x):
+        r"""
+        TESTS::
+
+            sage: hurwitz_zeta(x, 1)
+            zeta(x)
+            sage: hurwitz_zeta(4, 3)
+            1/90*pi^4 - 17/16
+            sage: hurwitz_zeta(-4, x)
+            -1/5*x^5 + 1/2*x^4 - 1/3*x^3 + 1/30*x
+            sage: hurwitz_zeta(3, 0.5)
+            8.41439832211716
+        """
+        co = get_coercion_model().canonical_coercion(s, x)[0]
+        if is_inexact(co) and not isinstance(co, Expression):
+            return self._evalf_(s, x, parent=parent(co))
+        if x == 1:
+            return zeta(s)
+        if s in ZZ and s > 1:
+            return ((-1) ** s) * psi(s - 1, x) / factorial(s - 1)
+        elif s in ZZ and s < 0:
+            return -bernoulli_polynomial(x, -s + 1) / (-s + 1)
+        else:
+            return
+
+    def _evalf_(self, s, x, parent):
+        r"""
+        TESTS::
+
+            sage: hurwitz_zeta(11/10, 1/2).n()
+            12.1038134956837
+            sage: hurwitz_zeta(11/10, 1/2).n(100)
+            12.103813495683755105709077413
+            sage: hurwitz_zeta(11/10, 1 + 1j).n()
+            9.85014164287853 - 1.06139499403981*I
+        """
+        from mpmath import zeta
+        return mpmath_utils.call(zeta, s, x, parent=parent)
+
+    def _derivative_(self, s, x, diff_param):
+        r"""
+        TESTS::
+
+            sage: y = var('y')
+            sage: diff(hurwitz_zeta(x, y), y)
+            -x*hurwitz_zeta(x + 1, y)
+        """
+        if diff_param == 1:
+            return -s * hurwitz_zeta(s + 1, x)
+        else:
+            raise NotImplementedError('derivative with respect to first '
+                                      'argument')
+
+hurwitz_zeta_func = Function_HurwitzZeta()
+
+
+def hurwitz_zeta(s, x, prec=None, **kwargs):
+    r"""
+    The Hurwitz zeta function `\zeta(s, x)`, where `s` and `x` are complex.
+
+    The Hurwitz zeta function is one of the many zeta functions. It
+    defined as
+
+    .. math::
+
+             \zeta(s, x) = \sum_{k=0}^{\infty} (k + x)^{-s}.
+
+
+    When `x = 1`, this coincides with Riemann's zeta function.
+    The Dirichlet L-functions may be expressed as a linear combination
+    of Hurwitz zeta functions.
+
+    EXAMPLES::
+
+        sage: hurwitz_zeta(x, 1)
+        zeta(x)
+        sage: hurwitz_zeta(4, 3)
+        1/90*pi^4 - 17/16
+        sage: hurwitz_zeta(-4, x)
+        -1/5*x^5 + 1/2*x^4 - 1/3*x^3 + 1/30*x
+        sage: hurwitz_zeta(3, 1/2).n()
+        8.41439832211716
+        sage: hurwitz_zeta(11/10, 1/2).n()
+        12.1038134956837
+        sage: hurwitz_zeta(3, x).series(x, 60).subs(x=0.5).n()
+        8.41439832211716
+        sage: hurwitz_zeta(3, 0.5)
+        8.41439832211716
+
+    REFERENCES:
+
+    - http://en.wikipedia.org/wiki/Hurwitz_zeta_function
+    """
+    if prec:
+        deprecation(15095, 'the syntax hurwitz_zeta(s, x, prec) has been '
+                           'deprecated. Use hurwitz_zeta(s, x).n(digits=prec) '
+                           'instead.')
+        return hurwitz_zeta_func(s, x).n(digits=prec)
+    return hurwitz_zeta_func(s, x, **kwargs)
+
+
 class Function_zetaderiv(GinacFunction):
     def __init__(self):
         r"""
@@ -112 +234 @@
             n
             sage: zetaderiv(n,x)
             zetaderiv(n, x)
+            sage: zetaderiv(1, 4).n()
+            -0.0689112658961254
+            sage: import mpmath; mpmath.diff(lambda x: mpmath.zeta(x), 4)
+            mpf('-0.068911265896125382')
 
         TESTS::
 
@@ -123 +249 @@
         """
         GinacFunction.__init__(self, "zetaderiv", nargs=2)
 
+    def _evalf_(self, n, x, parent):
+        from mpmath import zeta
+        return mpmath_utils.call(zeta, x, 1, n, parent=parent)
+
 zetaderiv = Function_zetaderiv()
 
 def zeta_symmetric(s):