Coulomb, Whittaker and parabolic cylinder function

Coulomb, Whittaker and parabolic cylinder function#

Coulomb wave functions are solutions of the Coulomb wave equation

\[y'' + \left(1 - \frac{2 \eta}{z} - \frac{\ell(\ell+1)}{z^2}\right) y = 0\]

which is the radial Schrödinger equation for a charged particle in a Coulomb potential \(1/z\), where \(\ell\) is the orbital angular momentum and \(\eta\) is the Sommerfeld parameter. The standard solutions are named \(F_{\ell}(\eta,z)\) (regular at the origin \(z = 0\)) and \(G_{\ell}(\eta,z)\) (irregular at the origin). The irregular solutions \(H^{\pm}_{\ell}(\eta,z) = G_{\ell}(\eta,z) \pm i F_{\ell}(\eta,z)\) are also used. The redundant functions \(H^{\pm}\) are provided explicitly since taking the linear combination of F and G suffers from cancellation in parts of the complex plane.

Coulomb wave functions are special cases of confluent hypergeometric functions. The normalization constants and connection formulas are discussed in Dzieciol et al. [308], Gaspard [357], Michel [436] and chapter 33 in NIST [852]. In this implementation, we define the analytic continuations of all the functions so that the branch cut with respect to z is placed on the negative real axis.

Normalizing Gamow constant for Coulomb wave functions#

math53.coulomb_cl(l, eta)#

Returns the normalizing Gamow constant for Coulomb wave functions. See also Wikipedia [1486], MathWorld [1115], NIST [852], Thompson and Barnett [853], Michel [436], Ehrhardt [309] (3.1.10.1), Mpmath [783].

Gives the normalizing Gamow constant for Coulomb wave functions,

\[C_l(\eta) = 2^l \exp\left(-\pi \eta/2 + [\log \Gamma(1+l+i\eta) + \log \Gamma(1+l-i\eta)]/2 - \log \Gamma(2l+2)\right),\]

where the log gamma function with continuous imaginary part away from the negative half axis is implied.

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.CoulombCL(3, 0.5)
xreal('5.2359877559829887307E-1')
>>> xreal.CoulombCL(3, '0.51')
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.CoulombCL(3, 0.5)
Gpr('5.2359877559829887307E-1')
>>> Gpr.CoulombCL(3, '0.51')
Gpr('5.3518479027559984754E-1')

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; l = '10'; eta = '3.0'
>>> \mathrm{d}x = dec.coulombc(l, eta); mx = mpm.coulombc(l, eta); gx = gmp.coulombc(l, eta)
>>> fx = fpm.coulombc(l, eta); ax = apm.coulombc(l, eta)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  4.281649626126579562163201610118157025275E-13
mpm:  4.281649626126579562163201610118157025275e-13
gmp:  4.281649626126579562163201610118157025275E-13
fpm:  4.28164962612658E-13
apm:  4.281649626126579562163201610118157025382e-13 (1.141e-35%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; l = '10'; eta = '3 + 4j'
>>> \mathrm{d}z = dec.coulombc(l, eta); mz = mpm.coulombc(l, eta); gz = gmp.coulombc(l, eta)
>>> fz = fpm.coulombc(l, eta); az = apm.coulombc(l, eta)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 3.4717690236181999723E-13              - 8.0361659919956253403E-13j
mpm: 3.4717690236181999723e-13              - 8.0361659919956253403e-13j
gmp: 3.4717690236181999723E-13              - 8.0361659919956253403E-13j
fpm: 3.47176902361820E-13                   - 8.03616599199563E-13j
apm: 3.4717690236182000026e-13 (1.386e-15%) - 8.0361659919956253696e-13 (-9.468e-16%)j

Coulomb phase shift \(\sigma_L(\eta)\)#

math53.coulomb_sl(L, eta)#

Returns the Coulomb phase shift for Coulomb wave functions.

See also: Ehrhardt [309] (3.1.10.2).

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.CoulombSL(3, 0.5)
xreal('5.2359877559829887307E-1')
>>> xreal.CoulombSL(3, '0.51')
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.CoulombSL(3, 0.5)
Gpr('5.2359877559829887307E-1')
>>> Gpr.CoulombSL(3, '0.51')
Gpr('5.3518479027559984754E-1')

Regular Coulomb wave functions \(F_l(\eta, x), F'_l(\eta, x)\)#

math53.coulomb_f_fprime(L, eta, x)#

Returns the Coulomb wave function F. See also Wikipedia [1486], MathWorld [1115], NIST [852], Ehrhardt [309] (3.1.10.3), Flint [838], Flint [830], Mpmath [773].

Calculates the regular Coulomb wave function

\[F_l(\eta,z) = C_l(\eta) z^{l+1} e^{-iz} \,_1F_1(l+1-i\eta, 2l+2, 2iz)\]

Calculates the regular Coulomb wave function

\[F_l(\eta,z) = C_l(\eta) z^{l+1} e^{-iz} \,_1F_1(l+1-i\eta, 2l+2, 2iz)\]

where the normalization constant \(C_l(\eta)\) is as calculated by coulombc(). This function solves the differential equation

\[f''(z) + \left(1-\frac{2\eta}{z}-\frac{l(l+1)}{z^2}\right) f(z) = 0.\]

A second linearly independent solution is given by the irregular Coulomb wave function \(G_l(\eta,z)\) (see coulombg()) and thus the general solution is \(f(z) = C_1 F_l(\eta,z) + C_2 G_l(\eta,z)\) for arbitrary constants \(C_1\), \(C_2\).

Physically, the Coulomb wave functions give the radial solution to the Schrodinger equation for a point particle in a \(1/z\) potential; \(z\) is then the radius and \(l\), \(\eta\) are quantum numbers.

The Coulomb wave functions with real parameters are defined in Abramowitz & Stegun, section 14. However, all parameters are permitted to be complex in this implementation (see references).

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.CoulombFFp(3, 0.5, 2.25)
xreal('5.2359877559829887307E-1')
>>> xreal.CoulombFFp(3, 0.5, 8.25)
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.CoulombFFp(3, 0.5, 2.25)
Gpr('5.2359877559829887307E-1')
>>> Gpr.CoulombFFp(3, 0.5, 8.25)
Gpr('5.3518479027559984754E-1')

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; l = '10'; eta = '3.0'; x = '5.0'
>>> \mathrm{d}x = dec.coulombf(l, eta, x); mx = mpm.coulombf(l, eta, x); gx = gmp.coulombf(l, eta, x)
>>> fx = fpm.coulombf(l, eta, x); ax = apm.coulombf(l, eta, x)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  4.696937811195414371006759141101351859462E-5
mpm:  4.696937811195414371006759141101351859462e-5
gmp:  4.696937811195414371006759141101351859462E-05
fpm:  4.69693781119541E-05
apm:  4.696937811195414371006759141101351859462e-5 (2.238e-39%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; l = '10'; eta = '3 + 4j'; z = '5.0 + 3j'
>>> \mathrm{d}z = dec.coulombf(l, eta, z); mz = mpm.coulombf(l, eta, z); gz = gmp.coulombf(l, eta, z)
>>> fz = fpm.coulombf(l, eta, z); az = apm.coulombf(l, eta, z)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 2.0437700551051474840E-4              + 1.0838222727919637420E-4j
mpm: 2.0437700551051474840e-4              + 1.0838222727919637420e-4j
gmp: 2.0437700551051474840E-04             + 1.0838222727919637420E-04j
fpm: 2.04377005510515E-04                  + 1.08382227279196E-04j
apm: 2.0437700551051474840e-4 (5.059e-19%) + 1.0838222727919637420e-4 (9.063e-19%)j

Regular Coulomb wave function \(F_l(\eta,z)\)#

math53.coulomb_f(L, eta, x)#

where ctx is math53` or ctxflint.

Returns the Coulomb wave function F. See also Wikipedia [1486], MathWorld [1115], NIST [852], Ehrhardt [309] (3.1.10.4), Mpmath [773].

Calculates the regular Coulomb wave function

\[F_l(\eta,z) = C_l(\eta) z^{l+1} e^{-iz} \,_1F_1(l+1-i\eta, 2l+2, 2iz)\]

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.CoulombF(3, 0.5, 2.25)
xreal('5.2359877559829887307E-1')
>>> xreal.CoulombF(3, 0.5, 8.25)
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.CoulombF(3, 0.5, 2.25)
Gpr('5.2359877559829887307E-1')
>>> Gpr.CoulombF(3, 0.5, 8.25)
Gpr('5.3518479027559984754E-1')

Irregular Coulomb wave functions \(G_l(\eta,z), x), G'_l(\eta,z)\)#

math53.coulomb_g(L, eta, x)#

where ctx is math53` or ctxflint.

Returns the irregular Coulomb wave function. See also Wikipedia [1486], MathWorld [1115], NIST [852], Ehrhardt [309] (3.1.10.5), Mpmath [774].

Calculates the irregular Coulomb wave function

\[G_l(\eta,z) = \frac{F_l(\eta,z) \cos(\chi) - F_{-l-1}(\eta,z)}{\sin(\chi)}\]

where \(\chi = \sigma_l - \sigma_{-l-1} - (l+1/2) \pi\) and \(\sigma_l(\eta) = (\log \Gamma(1+l+i\eta)-\log \Gamma(1+l-i\eta))/(2i)\).

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.CoulombGGp(3, 0.5, 2.25)
xreal('5.2359877559829887307E-1')
>>> xreal.CoulombGGp(3, 0.5, 8.25)
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.CoulombGGp(3, 0.5, 2.25)
Gpr('5.2359877559829887307E-1')
>>> Gpr.CoulombGGp(3, 0.5, 8.25)
Gpr('5.3518479027559984754E-1')

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; l = '10'; eta = '3.0'; x = '5.0'
>>> \mathrm{d}x = dec.coulombg(l, eta, x); mx = mpm.coulombg(l, eta, x); gx = gmp.coulombg(l, eta, x)
>>> fx = fpm.coulombg(l, eta, x); ax = apm.coulombg(l, eta, x)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  4.961542114057365010741557537693681681810E+3
mpm:  4.961542114057365010741557537693681681810e+3
gmp:  4.961542114057365010741557537693681681810E+03
fpm:  4.96154211405737E+03
apm:  4.961542114057365010741557537693681681810e+3 (3.791e-39%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; l = '10'; eta = '3 + 4j'; z = '5.0 + 3j'
>>> \mathrm{d}z = dec.coulombg(l, eta, z); mz = mpm.coulombg(l, eta, z); gz = gmp.coulombg(l, eta, z)
>>> fz = fpm.coulombg(l, eta, z); az = apm.coulombg(l, eta, z)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 1.2323201237533547519E+3              - 1.0269675160562813715E+2j
mpm: 1.2323201237533547519e+3              - 1.0269675160562813715e+2j
gmp: 1.2323201237533547519E+03             - 1.0269675160562813715E+02j
fpm: 1.23232012375335E+03                  - 1.02696751605628E+02j
apm: 1.2323201237533547519e+3 (4.223e-19%) - 1.0269675160562813715e+2 (-3.537e-18%)j
Contents