Ticket #9130: trac_9130_beta_function.2.patch

File trac_9130_beta_function.2.patch, 4.2 KB (added by ktkohl, 8 years ago)
  • doc/en/reference/functions.rst

    # HG changeset patch
    # User Karen T. Kohl <ktkohl96@gmail.com>
    # Date 1326168469 21600
    # Node ID 85b045143057e5da2aaac4f05fb3afca74e4b7aa
    # Parent  f189cfdef1c8669e8e8d88cfec579dc3c08ed343
    Trac 9130:  beta function access with error for complex input
    
    diff --git a/doc/en/reference/functions.rst b/doc/en/reference/functions.rst
    a b  
    99   sage/functions/transcendental
    1010   sage/functions/piecewise
    1111   sage/functions/orthogonal_polys
     12   sage/functions/other
    1213   sage/functions/special
    1314   sage/functions/wigner
    1415   sage/functions/generalized
    15    sage/functions/prime_pi
    16  No newline at end of file
     16   sage/functions/prime_pi
  • sage/functions/all.py

    diff --git a/sage/functions/all.py b/sage/functions/all.py
    a b  
    1515
    1616
    1717
    18 from other import ( ceil, floor, gamma, psi, factorial,
     18from other import ( ceil, floor, gamma, psi, factorial, beta,
    1919                    abs_symbolic, erf, sqrt,
    2020                    gamma_inc, incomplete_gamma,
    2121                    real_part, real,
  • sage/functions/other.py

    diff --git a/sage/functions/other.py b/sage/functions/other.py
    a b  
    11721172    def __init__(self):
    11731173        r"""
    11741174        Return the beta function.  This is defined by
    1175         `\Beta(p,q) = \int_0^1 t^{p-1}(1-t)^{1-q} dt`
     1175
     1176        .. math::
     1177
     1178            B(p,q) = \int_0^1 t^{p-1}(1-t)^{1-q} dt
     1179
    11761180        for complex input `p` and `q`.
     1181        Note that the order of arguments of does not matter:  `B(p,q)=B(q,p)`.
    11771182
    1178         It is computed by various libraries within Sage, depending on
    1179         the input type.
     1183        It is computed by GiNaC by either
     1184
     1185        .. math::
     1186
     1187            B(p,q) = \Gamma(p)\Gamma(q)/\Gamma(p+q)
     1188
     1189        or
     1190
     1191        .. math::
     1192
     1193            B(p,q) = (-1)^q B(1-p-q, q)
     1194
     1195        It is evaluated numerically in GiNaC by
     1196
     1197        .. math::
     1198
     1199            B(p,q) =  \exp(\log(\Gamma(p))+\log(\Gamma(q))-\log(\Gamma(p+q)))
     1200
    11801201
    11811202        INPUT:
    1182         -  ``p``, ``q`` - numbers or symbolic expressions.
     1203
     1204        -  ``p`` - number or symbolic expression
     1205
     1206        -  ``q`` - number or symbolic expression
     1207
     1208
    11831209        OUTPUT: number or symbolic expression (if input is symbolic)
     1210
    11841211        EXAMPLES::
     1212
    11851213            sage: beta(3,2)
    11861214            1/12
    11871215            sage: beta(3,1)
     
    11941222            0
    11951223            sage: beta(x/2,3)
    11961224            beta(1/2*x, 3)
     1225            sage: beta(.5,.5)
     1226            3.14159265358979
     1227            sage: beta(1,2+I)
     1228            -1/5*I + 2/5
     1229            sage: beta(1,2.0+I)
     1230            0.400000000000000 - 0.200000000000000*I
     1231
     1232        Note that the order of arguments does not matter::
     1233
     1234            sage: beta(1/2,3*x)
     1235            beta(3*x, 1/2)
     1236
     1237        The following fails because we haven't implemented
     1238        beta yet for general complex values::
     1239
     1240            sage: beta(2,1+5*I)
     1241            Traceback (most recent call last):
     1242            ...
     1243            NotImplementedError: beta not implemented for all complex arguments
     1244
    11971245        """
    11981246        GinacFunction.__init__(self, "beta", nargs=2,
    11991247                conversions=dict(maxima='beta', mathematica='Beta'))
    12001248
     1249    def __call__(self, p, q, prec=None, coerce=True, hold=False):
     1250        """
     1251
     1252        TESTS::
     1253
     1254            sage: beta(3,2)
     1255            1/12
     1256            sage: beta(3,1)
     1257            1/3
     1258            sage: beta(1/2,1/2)
     1259            beta(1/2, 1/2)
     1260            sage: beta(-1,1)
     1261            -1
     1262            sage: beta(-1/2,-1/2)
     1263            0
     1264            sage: beta(x/2,3)
     1265            beta(1/2*x, 3)
     1266            sage: beta(.5,.5)
     1267            3.14159265358979
     1268            sage: beta(2,1+5*I)
     1269            Traceback (most recent call last):
     1270            ...
     1271            NotImplementedError: beta not implemented for all complex arguments
     1272
     1273        """
     1274        try:
     1275            res = GinacFunction.__call__(self, p, q, coerce=coerce, hold=hold)
     1276        except TypeError, err:
     1277            if not str(err).startswith("cannot coerce"):
     1278                raise NotImplementedError, "beta not implemented for all complex arguments"
     1279
     1280        return res
     1281
     1282
    12011283beta = Function_beta()
    12021284
    12031285def _do_sqrt(x, prec=None, extend=True, all=False):