Ticket #15024: trac15024.patch

File trac15024.patch, 19.1 KB (added by eviatarbach, 8 years ago)
  • sage/functions/all.py

    # HG changeset patch
    # User Eviatar Bach <eviatarbach@gmail.com>
    # Date 1376006015 25200
    # Node ID 684d2ce97584d9c2424306687cd94b4c0937b4b6
    # Parent  2276f8addef20c5d1f59ebe11e82e7d5451e5cae
    Adding Hankel functions, making spherical Bessel and Hankel functions symbolic
    
    diff --git a/sage/functions/all.py b/sage/functions/all.py
    a b  
    2626
    2727from transcendental import (zeta, zetaderiv, zeta_symmetric, dickman_rho)
    2828
    29 from sage.functions.bessel import (bessel_I, bessel_J, bessel_K, bessel_Y, Bessel)
     29from bessel import (Bessel, bessel_I, bessel_J, bessel_K, bessel_Y, hankel1,
     30                    hankel2, spherical_bessel_J, spherical_bessel_Y,
     31                    spherical_hankel1, spherical_hankel2)
    3032
    3133from special import (hypergeometric_U,
    32                      spherical_bessel_J, spherical_bessel_Y,
    33                      spherical_hankel1, spherical_hankel2,
    3434                     spherical_harmonic, jacobi,
    3535                     inverse_jacobi,
    3636                     lngamma, error_fcn, elliptic_e,
  • sage/functions/bessel.py

    diff --git a/sage/functions/bessel.py b/sage/functions/bessel.py
    a b  
    9090   kind; they are also two linearly independent solutions of Bessel's
    9191   differential equation. They are named for Hermann Hankel.
    9292
     93-  When solving for separable solutions of Laplace's equation in
     94   spherical coordinates, the radial equation has the form:
     95
     96   .. math::
     97
     98         x^2 \frac{d^2 y}{dx^2} + 2x \frac{dy}{dx} + [x^2 - n(n+1)]y = 0.
     99
     100
     101   The spherical Bessel functions `j_n` and `y_n`,
     102   are two linearly independent solutions to this equation. They are
     103   related to the ordinary Bessel functions `J_n` and
     104   `Y_n` by:
     105
     106   .. math::
     107
     108         j_n(x) = \sqrt{\frac{\pi}{2x}} J_{n+1/2}(x),
     109
     110   .. math::
     111
     112         y_n(x) = \sqrt{\frac{\pi}{2x}} Y_{n+1/2}(x) = (-1)^{n+1} \sqrt{\frac{\pi}{2x}} J_{-n-1/2}(x).
     113
    93114EXAMPLES:
    94115
    95116    Evaluate the Bessel J function symbolically and numerically::
     
    143164
    144165AUTHORS:
    145166
     167    - Some of the documentation here has been adapted from David Joyner's
     168      original documentation of Sage's special functions module (2006).
     169
    146170    - Benjamin Jones (2012-12-27): initial version
    147171
    148     - Some of the documentation here has been adapted from David Joyner's
    149       original documentation of Sage's special functions module (2006).
     172    - Eviatar Bach (2013): Hankel and spherical Bessel and Hankel functions
    150173
    151174REFERENCES:
    152175
     
    370393        EXAMPLES::
    371394
    372395            sage: latex(bessel_J(1, x))
    373             \operatorname{J_{1}}(x)
     396            J_{1}(x)
    374397        """
    375         return r"\operatorname{J_{%s}}(%s)" % (latex(n), latex(z))
     398        return r"J_{%s}(%s)" % (latex(n), latex(z))
    376399
    377400bessel_J = Function_Bessel_J()
    378401
     
    530553        EXAMPLES::
    531554
    532555            sage: latex(bessel_Y(1, x))
    533             \operatorname{Y_{1}}(x)
     556            Y_{1}(x)
    534557        """
    535         return r"\operatorname{Y_{%s}}(%s)" % (latex(n), latex(z))
     558        return r"Y_{%s}(%s)" % (latex(n), latex(z))
    536559
    537560bessel_Y = Function_Bessel_Y()
    538561
     
    703726        EXAMPLES::
    704727
    705728            sage: latex(bessel_I(1, x))
    706             \operatorname{I_{1}}(x)
     729            I_{1}(x)
    707730        """
    708         return r"\operatorname{I_{%s}}(%s)" % (latex(n), latex(z))
     731        return r"I_{%s}(%s)" % (latex(n), latex(z))
    709732
    710733bessel_I = Function_Bessel_I()
    711734
     
    888911        EXAMPLES::
    889912
    890913            sage: latex(bessel_K(1, x))
    891             \operatorname{K_{1}}(x)
     914            K_{1}(x)
    892915        """
    893         return r"\operatorname{K_{%s}}(%s)" % (latex(n), latex(z))
     916        return r"K_{%s}(%s)" % (latex(n), latex(z))
    894917
    895918bessel_K = Function_Bessel_K()
    896919
     
    10661089    else:
    10671090        return _f
    10681091
     1092
     1093class Hankel1(BuiltinFunction):
     1094    r"""
     1095    The Hankel function of the first kind
     1096
     1097    DEFINITION:
     1098
     1099    .. math::
     1100
     1101        H_\nu^{(1)}(z) = J_{\nu}(z) + iY_{\nu}(z)
     1102
     1103    EXAMPLES::
     1104
     1105        sage: hankel1(3, 4.)
     1106        0.430171473875622 - 0.182022115953485*I
     1107        sage: latex(hankel1(3, x))
     1108        H_{3}^{(1)}(x)
     1109        sage: hankel1(3., x).series(x == 2, 10).subs(x=3).n()  # abs tol 1e-12
     1110        0.309062682819597 - 0.512591541605233*I
     1111        sage: hankel1(3, 3.)
     1112        0.309062722255252 - 0.538541616105032*I
     1113    """
     1114    def __init__(self):
     1115        BuiltinFunction.__init__(self, 'hankel1', nargs=2,
     1116                                 conversions=dict(maple='HankelH1',
     1117                                                  mathematica='HankelH1',
     1118                                                  maxima='hankel1',
     1119                                                  sympy='hankel1'))
     1120
     1121    def _eval_(self, nu, z):
     1122        nu, z = get_coercion_model().canonical_coercion(nu, z)
     1123        if is_inexact(nu) and not isinstance(nu, Expression):
     1124            return self._evalf_(nu, z, parent(nu))
     1125        return
     1126
     1127    def _evalf_(self, nu, z, parent):
     1128        from mpmath import hankel1
     1129        return mpmath_utils.call(hankel1, nu, z, parent=parent)
     1130
     1131    def _print_latex_(self, nu, z):
     1132        return r"H_{{{}}}^{{(1)}}({})".format(latex(nu), latex(z))
     1133
     1134    def _derivative_(self, nu, z, diff_param):
     1135        if diff_param == 1:
     1136            return (nu * hankel1(nu, z)) / z - hankel1(nu + 1, z)
     1137        else:
     1138            raise NotImplementedError('derivative with respect to order')
     1139
     1140hankel1 = Hankel1()
     1141
     1142
     1143class Hankel2(BuiltinFunction):
     1144    r"""
     1145    The Hankel function of the second kind
     1146
     1147    DEFINITION:
     1148
     1149    .. math::
     1150
     1151        H_\nu^{(2)}(z) = J_{\nu}(z) - iY_{\nu}(z)
     1152
     1153    EXAMPLES::
     1154
     1155        sage: hankel2(3, 4.)
     1156        0.430171473875622 + 0.182022115953485*I
     1157        sage: latex(hankel2(3, x))
     1158        H_{3}^{(2)}(x)
     1159        sage: hankel2(3., x).series(x == 2, 10).subs(x=3).n()  # abs tol 1e-12
     1160        0.309062682819597 + 0.512591541605234*I
     1161        sage: hankel2(3, 3.)
     1162        0.309062722255252 + 0.538541616105032*I
     1163    """
     1164    def __init__(self):
     1165        BuiltinFunction.__init__(self, 'hankel2', nargs=2,
     1166                                 conversions=dict(maple='HankelH2',
     1167                                                  mathematica='HankelH2',
     1168                                                  maxima='hankel2',
     1169                                                  sympy='hankel2'))
     1170
     1171    def _eval_(self, nu, z):
     1172        nu, z = get_coercion_model().canonical_coercion(nu, z)
     1173        if is_inexact(nu) and not isinstance(nu, Expression):
     1174            return self._evalf_(nu, z, parent(nu))
     1175        return
     1176
     1177    def _evalf_(self, nu, z, parent):
     1178        from mpmath import hankel2
     1179        return mpmath_utils.call(hankel2, nu, z, parent=parent)
     1180
     1181    def _print_latex_(self, nu, z):
     1182        return r"H_{{{}}}^{{(2)}}({})".format(latex(nu), latex(z))
     1183
     1184    def _derivative_(self, nu, z, diff_param):
     1185        if diff_param == 1:
     1186            return (Integer(1) / 2) * (hankel2(nu - 1, z) - hankel2(nu + 1, z))
     1187        else:
     1188            raise NotImplementedError('derivative with respect to order')
     1189
     1190hankel2 = Hankel2()
     1191
     1192
     1193class SphericalBesselJ(BuiltinFunction):
     1194    r"""
     1195    The spherical Bessel function of the first kind
     1196
     1197    DEFINITION:
     1198
     1199    .. math::
     1200
     1201        j_n(z) = \sqrt{\frac{1}{2}\pi/z} J_{n + \frac{1}{2}}(z)
     1202
     1203    EXAMPLES::
     1204
     1205        sage: spherical_bessel_J(3., x).series(x == 2, 10).subs(x=3).n()
     1206        0.152051648665037
     1207        sage: spherical_bessel_J(3., 3)
     1208        0.152051662030533
     1209        sage: spherical_bessel_J(4, x).simplify()
     1210        -((45/x^2 - 105/x^4 - 1)*sin(x) + 5*(21/x^2 - 2)*cos(x)/x)/x
     1211        sage: latex(spherical_bessel_J(4, x))
     1212        j_{4}(x)
     1213    """
     1214    def __init__(self):
     1215        BuiltinFunction.__init__(self, 'spherical_bessel_J', nargs=2,
     1216                                 conversions=dict(mathematica=
     1217                                                  'SphericalBesselJ',
     1218                                                  maxima='spherical_bessel_j',
     1219                                                  sympy='jn'))
     1220
     1221    def _eval_(self, n, z):
     1222        n, z = get_coercion_model().canonical_coercion(n, z)
     1223        if is_inexact(n) and not isinstance(n, Expression):
     1224            return self._evalf_(n, z, parent(n))
     1225        return
     1226
     1227    def _evalf_(self, n, z, parent):
     1228        return mpmath_utils.call(spherical_bessel_f, 'besselj', n, z,
     1229                                 parent=parent)
     1230
     1231    def _print_latex_(self, n, z):
     1232        return r"j_{{{}}}({})".format(latex(n), latex(z))
     1233
     1234    def _derivative_(self, n, z, diff_param):
     1235        if diff_param == 1:
     1236            return (spherical_bessel_J(n - 1, z) -
     1237                    ((n + 1) / z) * spherical_bessel_J(n, z))
     1238        else:
     1239            raise NotImplementedError('derivative with respect to order')
     1240
     1241spherical_bessel_J = SphericalBesselJ()
     1242
     1243
     1244class SphericalBesselY(BuiltinFunction):
     1245    r"""
     1246    The spherical Bessel function of the second kind
     1247
     1248    DEFINITION:
     1249
     1250    .. math::
     1251
     1252        y_n(z) = \sqrt{\frac{1}{2}\pi/z} Y_{n + \frac{1}{2}}(z)
     1253
     1254    EXAMPLES::
     1255
     1256        sage: spherical_bessel_Y(-3, x).simplify()
     1257        ((3/x^2 - 1)*sin(x) - 3*cos(x)/x)/x
     1258        sage: spherical_bessel_Y(3 + 2 * I, 5 - 0.2 * I)
     1259        -0.270205813266440 - 0.615994702714957*I
     1260        sage: integrate(spherical_bessel_Y(0, x), x)
     1261        -1/2*Ei(I*x) - 1/2*Ei(-I*x)
     1262        sage: latex(spherical_bessel_Y(0, x))
     1263        y_{0}(x)
     1264    """
     1265    def __init__(self):
     1266        BuiltinFunction.__init__(self, 'spherical_bessel_Y', nargs=2,
     1267                                 conversions=dict(mathematica=
     1268                                                  'SphericalBesselY',
     1269                                                  maxima='spherical_bessel_y',
     1270                                                  sympy='yn'))
     1271
     1272    def _eval_(self, n, z):
     1273        n, z = get_coercion_model().canonical_coercion(n, z)
     1274        if is_inexact(n) and not isinstance(n, Expression):
     1275            return self._evalf_(n, z, parent(n))
     1276        return
     1277
     1278    def _evalf_(self, n, z, parent):
     1279        return mpmath_utils.call(spherical_bessel_f, 'bessely', n, z,
     1280                                 parent=parent)
     1281
     1282    def _print_latex_(self, n, z):
     1283        return r"y_{{{}}}({})".format(latex(n), latex(z))
     1284
     1285    def _derivative_(self, n, z, diff_param):
     1286        if diff_param == 1:
     1287            return (-spherical_bessel_Y(n, z) / (2 * z) +
     1288                    (spherical_bessel_Y(n - 1, z) -
     1289                     spherical_bessel_Y(n + 1, z)) / 2)
     1290        else:
     1291            raise NotImplementedError('derivative with respect to order')
     1292
     1293spherical_bessel_Y = SphericalBesselY()
     1294
     1295
     1296class SphericalHankel1(BuiltinFunction):
     1297    r"""
     1298    The spherical Hankel function of the first kind
     1299
     1300    DEFINITION:
     1301
     1302    .. math::
     1303
     1304        h_n^{(1)}(z) = \sqrt{\frac{1}{2}\pi/z} H_{n + \frac{1}{2}}^{(1)}(z)
     1305
     1306    EXAMPLES::
     1307
     1308        sage: spherical_hankel1(1, x).simplify()
     1309        -(x + I)*e^(I*x)/x^2
     1310        sage: spherical_hankel1(3 + 2 * I, 5 - 0.2 * I)
     1311        1.25375216869913 - 0.518011435921789*I
     1312        sage: integrate(spherical_hankel1(3, x), x)
     1313        Ei(I*x) - 6*gamma(-1, -I*x) - 15*gamma(-2, -I*x) - 15*gamma(-3, -I*x)
     1314        sage: latex(spherical_hankel1(3, x))
     1315        h_{3}^{(1)}(x)
     1316    """
     1317    def __init__(self):
     1318        BuiltinFunction.__init__(self, 'spherical_hankel1', nargs=2,
     1319                                 conversions=dict(mathematica=
     1320                                                  'SphericalHankelH1',
     1321                                                  maxima='spherical_hankel1'))
     1322
     1323    def _eval_(self, n, z):
     1324        n, z = get_coercion_model().canonical_coercion(n, z)
     1325        if is_inexact(n) and not isinstance(n, Expression):
     1326            return self._evalf_(n, z, parent(n))
     1327        return
     1328
     1329    def _evalf_(self, n, z, parent):
     1330        return mpmath_utils.call(spherical_bessel_f, 'hankel1', n, z,
     1331                                 parent=parent)
     1332
     1333    def _print_latex_(self, n, z):
     1334        return r"h_{{{}}}^{{(1)}}({})".format(latex(n), latex(z))
     1335
     1336    def _derivative_(self, n, z, diff_param):
     1337        if diff_param == 1:
     1338            return (-spherical_hankel1(n, z) / (2 * z) +
     1339                    (spherical_hankel1(n - 1, z) -
     1340                     spherical_hankel1(n + 1, z)) / 2)
     1341        else:
     1342            raise NotImplementedError('derivative with respect to order')
     1343
     1344spherical_hankel1 = SphericalHankel1()
     1345
     1346
     1347class SphericalHankel2(BuiltinFunction):
     1348    r"""
     1349    The spherical Hankel function of the second kind
     1350
     1351    DEFINITION:
     1352
     1353    .. math::
     1354
     1355        h_n^{(2)}(z) = \sqrt{\frac{1}{2}\pi/z} H_{n + \frac{1}{2}}^{(2)}(z)
     1356
     1357    EXAMPLES::
     1358
     1359        sage: spherical_hankel2(1, x).simplify()
     1360        -(x - I)*e^(-I*x)/x^2
     1361        sage: spherical_hankel2(3 + 2*I, 5 - 0.2*I)
     1362        0.0217627632692163 + 0.0224001906110906*I
     1363        sage: integrate(spherical_hankel2(3, x), x)
     1364        Ei(-I*x) - 6*gamma(-1, I*x) - 15*gamma(-2, I*x) - 15*gamma(-3, I*x)
     1365        sage: latex(spherical_hankel2(3, x))
     1366        h_{3}^{(2)}(x)
     1367    """
     1368    def __init__(self):
     1369        BuiltinFunction.__init__(self, 'spherical_hankel2', nargs=2,
     1370                                 conversions=dict(mathematica=
     1371                                                  'SphericalHankelH2',
     1372                                                  maxima='spherical_hankel2'))
     1373
     1374    def _eval_(self, n, z):
     1375        n, z = get_coercion_model().canonical_coercion(n, z)
     1376        if is_inexact(n) and not isinstance(n, Expression):
     1377            return self._evalf_(n, z, parent(n))
     1378        return
     1379
     1380    def _evalf_(self, n, z, parent):
     1381        return mpmath_utils.call(spherical_bessel_f, 'hankel2', n, z,
     1382                                 parent=parent)
     1383
     1384    def _print_latex_(self, n, z):
     1385        return r"h_{{{}}}^{{(2)}}({})".format(latex(n), latex(z))
     1386
     1387    def _derivative_(self, n, z, diff_param):
     1388        if diff_param == 1:
     1389            return (-spherical_hankel2(n, z) / (2 * z) +
     1390                    (spherical_hankel2(n - 1, z) -
     1391                     spherical_hankel2(n + 1, z)) / 2)
     1392        else:
     1393            raise NotImplementedError('derivative with respect to order')
     1394
     1395spherical_hankel2 = SphericalHankel2()
     1396
     1397
     1398def spherical_bessel_f(F, n, z):
     1399    r"""
     1400    Numerically evaluate the spherical version, `f`, of the Bessel function `F`
     1401    by computing `f_n(z) = \sqrt{\frac{1}{2}\pi/z} F_{n + \frac{1}{2}}(z)`.
     1402    According to Abramowitz & Stegun, this identity holds for the Bessel
     1403    functions `J`, `Y`, `K`, `I`, `H^{(1)}`, and `H^{(2)}`.
     1404
     1405    EXAMPLES::
     1406
     1407        sage: from sage.functions.bessel import spherical_bessel_f
     1408        sage: spherical_bessel_f('besselj', 3, 4)
     1409        mpf('0.22924385795503024')
     1410        sage: spherical_bessel_f('hankel1', 3, 4)
     1411        mpc(real='0.22924385795503024', imag='-0.21864196590306359')
     1412    """
     1413    from mpmath import mp
     1414    ctx = mp
     1415    prec = ctx.prec
     1416    try:
     1417        n = ctx.convert(n)
     1418        z = ctx.convert(z)
     1419        ctx.prec += 10
     1420        Fz = getattr(ctx, F)(n + 0.5, z)
     1421        hpi = 0.5 * ctx.pi()
     1422        ctx.prec += 10
     1423        hpioz = hpi / z
     1424        ctx.prec += 10
     1425        sqrthpioz = ctx.sqrt(hpioz)
     1426        ctx.prec += 10
     1427        return sqrthpioz * Fz
     1428    finally:
     1429        ctx.prec = prec
     1430
    10691431####################################################
    10701432###  to be removed after the deprecation period  ###
    10711433####################################################
  • sage/functions/special.py

    diff --git a/sage/functions/special.py b/sage/functions/special.py
    a b  
    105105   
    106106   .. math::
    107107
    108      \int_{\theta=0}^\pi\int_{\varphi=0}^{2\pi} Y_\ell^mY_{\ell'}^{m'*}\,d\Omega =\delta_{\ell\ell'}\delta_{mm'}\quad\quad d\Omega =\sin\theta\,d\varphi\,d\theta .
    109 
    110 
    111 
    112 -  When solving for separable solutions of Laplace's equation in
    113    spherical coordinates, the radial equation has the form:
    114    
    115    .. math::
    116 
    117          x^2 \frac{d^2 y}{dx^2} + 2x \frac{dy}{dx} + [x^2 - n(n+1)]y = 0.
    118 
    119 
    120    The spherical Bessel functions `j_n` and `y_n`,
    121    are two linearly independent solutions to this equation. They are
    122    related to the ordinary Bessel functions `J_n` and
    123    `Y_n` by:
    124    
    125    .. math::
    126 
    127          j_n(x) = \sqrt{\frac{\pi}{2x}} J_{n+1/2}(x),
    128 
    129 
    130    
    131    .. math::
    132 
    133          y_n(x) = \sqrt{\frac{\pi}{2x}} Y_{n+1/2}(x)     = (-1)^{n+1} \sqrt{\frac{\pi}{2x}} J_{-n-1/2}(x). 
    134 
    135 
     108     \int_{\theta=0}^\pi\int_{\varphi=0}^{2\pi} Y_\ell^mY_{\ell'}^{m'*}\,d\Omega =\delta_{\ell\ell'}\delta_{mm'}\quad\quad d\Omega =\sin\theta\,d\varphi\,d\theta .
    136109
    137110-  For `x>0`, the confluent hypergeometric function
    138111   `y = U(a,b,x)` is defined to be the solution to Kummer's
     
    666639    else:
    667640        raise ValueError, "unknown algorithm '%s'"%algorithm
    668641
    669 def spherical_bessel_J(n, var, algorithm="maxima"):
    670     r"""
    671     Returns the spherical Bessel function of the first kind for
    672     integers n >= 1.
    673    
    674     Reference: AS 10.1.8 page 437 and AS 10.1.15 page 439.
    675    
    676     EXAMPLES::
    677    
    678         sage: spherical_bessel_J(2,x)
    679         ((3/x^2 - 1)*sin(x) - 3*cos(x)/x)/x
    680         sage: spherical_bessel_J(1, 5.2, algorithm='scipy')
    681         -0.12277149950007...
    682         sage: spherical_bessel_J(1, 3, algorithm='scipy')
    683         0.345677499762355...
    684     """
    685     if algorithm=="scipy":
    686         from scipy.special.specfun import sphj
    687         return sphj(int(n), float(var))[1][-1]
    688     elif algorithm == 'maxima':
    689         _init()
    690         return meval("spherical_bessel_j(%s,%s)"%(ZZ(n),var))
    691     else:
    692         raise ValueError, "unknown algorithm '%s'"%algorithm
    693    
    694 def spherical_bessel_Y(n,var, algorithm="maxima"):
    695     r"""
    696     Returns the spherical Bessel function of the second kind for
    697     integers n -1.
    698    
    699     Reference: AS 10.1.9 page 437 and AS 10.1.15 page 439.
    700    
    701     EXAMPLES::
    702    
    703         sage: x = PolynomialRing(QQ, 'x').gen()
    704         sage: spherical_bessel_Y(2,x)
    705         -((3/x^2 - 1)*cos(x) + 3*sin(x)/x)/x
    706     """
    707     if algorithm=="scipy":
    708         import scipy.special
    709         ans = str(scipy.special.sph_yn(int(n),float(var)))
    710         ans = ans.replace("(","")
    711         ans = ans.replace(")","")
    712         ans = ans.replace("j","*I")
    713         return sage_eval(ans)
    714     elif algorithm == 'maxima':
    715         _init()
    716         return meval("spherical_bessel_y(%s,%s)"%(ZZ(n),var))
    717     else:
    718         raise ValueError, "unknown algorithm '%s'"%algorithm
    719 
    720 def spherical_hankel1(n, var):
    721     r"""
    722     Returns the spherical Hankel function of the first kind for
    723     integers `n > -1`, written as a string. Reference: AS
    724     10.1.36 page 439.
    725    
    726     EXAMPLES::
    727    
    728         sage: spherical_hankel1(2, x)
    729         (I*x^2 - 3*x - 3*I)*e^(I*x)/x^3
    730     """
    731     return maxima_function("spherical_hankel1")(ZZ(n), var)
    732 
    733 def spherical_hankel2(n,x):
    734     r"""
    735     Returns the spherical Hankel function of the second kind for
    736     integers `n > -1`, written as a string. Reference: AS 10.1.17 page
    737     439.
    738    
    739     EXAMPLES::
    740    
    741         sage: spherical_hankel2(2, x)
    742         (-I*x^2 - 3*x + 3*I)*e^(-I*x)/x^3
    743    
    744     Here I = sqrt(-1).
    745     """
    746     return maxima_function("spherical_hankel2")(ZZ(n), x)
    747 
    748642def spherical_harmonic(m,n,x,y):
    749643    r"""
    750644    Returns the spherical Harmonic function of the second kind for