Chebyshev, Gegenbauer and Jacobi polynomials

Chebyshev, Gegenbauer and Jacobi polynomials#

Chebyshev polynomial (or function) of the first kind, \(T_n(x)\)#

ctx.chebyshev_t(n, x)#

where ctx is math53, ctxboost or ctxflint.

Returns \(\displaystyle T_n(z) = {}_2F_1\left(-n,n,\frac{1}{2},\frac{1-z}{2}\right)\), the Chebyshev polynomial of the first kind. The \(T_n (x)\) are orthogonal on the interval \((-1, 1)\), with respect to the weight function \(w(x) = (1 - x^2 )^{-1/2}\).

For integer \(n\), the following recursion can be used, with \(T_n (x) = T_{-n} (x)\):

\begin{eqnarray} T_0 (x) & = & 1 \\ T_1 (x) & = & x \nonumber \\ T_{n+1} (x)& = & 2x T_{n}(x) - T_{n-1}(x). \nonumber \end{eqnarray}

See also Wikipedia [1405], MathWorld [988], NIST [419], BoostMath [120], Ehrhardt [309] (3.7.1), Flint [825], Flint [821], Mpmath [657], Ehrhardt [309] (3.7.5).

An example in Python

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

An example in Visual Basic

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

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; n = '10'; x = '5.0'
>>> \mathrm{d}x = dec.chebyt(n, x); mx = mpm.chebyt(n, x); gx = gmp.chebyt(n, x)
>>> fx = fpm.chebyt(n, x); ax = apm.chebyt(n, x)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  4.517251249000000000000000000000000000000E+9
mpm:  4.517251249000000000000000000000000000000e+9
gmp:  4.517251249000000000000000000000000000000E+09
fpm:  4.51725124900000E+09
apm:  4.517251249000000000000000000000000000000e+9 (0.0%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; n = '10'; z = '5.0 + 3j'
>>> \mathrm{d}z = dec.chebyt(n, z); mz = mpm.chebyt(n, z); gz = gmp.chebyt(n, z)
>>> fz = fpm.chebyt(n, z); az = apm.chebyt(n, z)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 1.5445350751000000000E+10        - 1.6336798500000000000E+10j
mpm: 1.5445350751000000000e+10        - 1.6336798500000000000e+10j
gmp: 1.5445350751000000000E+10        - 1.6336798500000000000E+10j
fpm: 1.54453507510000E+10             - 1.63367985000000E+10j
apm: 1.5445350751000000000e+10 (0.0%) - 1.6336798500000000000e+10 (0.0%)j

Chebyshev polynomial of the second kind, \(U_n(x)\)#

ctx.chebyshev_u(n, x)#

where ctx is math53, ctxboost or ctxflint.

Returns \(\displaystyle U_n(z) = (n+1) {}_2F_1\left(-n,n+2,\frac{3}{2},\frac{1-z}{2}\right)\), the Chebyshev polynomial of the second kind. The \(U_n (x)\) are orthogonal on the interval \((-1, 1)\), with respect to the weight function \(w(x) = (1 - x^2 )^{1/2}\).

For integer \(n\), the following recursion can be used, with \(U_{-1} (x) = 0\) and \(U_n (x) = -U_{-n-2} (x)\):

\begin{eqnarray} U_0 (x) & = & 1 \\ U_1 (x) & = & 2x \nonumber \\ U_{n+1} (x)& = & 2x U_{n}(x) - U_{n-1}(x). \nonumber \end{eqnarray}

See also Wikipedia [1405], MathWorld [989], NIST [419], Ehrhardt [309] (3.7.2), BoostMath [120], Flint [825], Flint [821], Mpmath [658].

An example in Python

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

An example in Visual Basic

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

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; n = '10'; x = '5.0'
>>> \mathrm{d}x = dec.chebyu(n, x); mx = mpm.chebyu(n, x); gx = gmp.chebyu(n, x)
>>> fx = fpm.chebyu(n, x); ax = apm.chebyu(n, x)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  9.127651499000000000000000000000000000000E+9
mpm:  9.127651499000000000000000000000000000000e+9
gmp:  9.127651499000000000000000000000000000000E+09
fpm:  9.12765149900000E+09
apm:  9.127651499000000000000000000000000000000e+9 (0.0%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; n = '10'; z = '5.0 + 3j'
>>> \mathrm{d}z = dec.chebyu(n, z); mz = mpm.chebyu(n, z); gz = gmp.chebyu(n, z)
>>> fz = fpm.chebyu(n, z); az = apm.chebyu(n, z)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 3.0778307711000000000E+10        - 3.2988132600000000000E+10j
mpm: 3.0778307711000000000e+10        - 3.2988132600000000000e+10j
gmp: 3.0778307711000000000E+10        - 3.2988132600000000000E+10j
fpm: 3.07783077110000E+10             - 3.29881326000000E+10j
apm: 3.0778307711000000000e+10 (0.0%) - 3.2988132600000000000e+10 (0.0%)j

Chebyshev polynomials of the third kind, \(V_n(x)\)#

math53.chebyshev_v(n, x)#

Returns \(\displaystyle V_n(x)\), the Chebyshev polynomial of the first kind. The \(V_n (x)\) are orthogonal on the interval \((-1, 1)\), with respect to the weight function \(w(x) = (1 + x^2 )^{1/2} (1 - x)^{-1/2}\).

The function can also be calculated as \(\displaystyle V_n(x) = (-1)^n (2n+1) {}_2F_1\left(-n,n+1,\frac{3}{2},\frac{1+x}{2}\right)\), which allows for complex \(n\) and \(x\).

We also have \(\displaystyle V_n(x) = \sqrt{\frac{2}{1+x}} T_{2n+1} \left( \sqrt{\frac{x+1}{2}} \right)\) for \(x \ge 0\), and \(V_n (x) = (-1)^n W_{n}(-x)\) for \(x < 0\).

For integer \(n\) and real \(x\), the following recursion can be used, with \(V_{-n-1}(x) = V_{n}(x)\):

\begin{eqnarray} V_0 (x) & = & 1 \\ V_1 (x) & = & 2x-1 \nonumber \\ V_{n+1} (x)& = & 2x V_{n}(x) - V_{n-1}(x). \nonumber \end{eqnarray}

See also Wikipedia [1405], MathWorld [988], NIST [419], Ehrhardt [309] (3.7.3).

An example in Python

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

An example in Visual Basic

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

Chebyshev polynomials of the fourth kind, \(W_n(x)\)#

math53.chebyshev_w(n, x)#

Returns \(\displaystyle W_k(z)\), the Chebyshev polynomial of the fourth kind of degree \(n \ge 0\). The \(W_n (x)\) are orthogonal on the interval \((-1, 1)\), with respect to the weight function \(w(x) = (1 - x)^{1/2} (1 + x^2 )^{-1/2}\).

The function can also be calculated as \(\displaystyle W_n(z) = (-1)^n {}_2F_1\left(-n,n+1,\frac{1}{2},\frac{1+x}{2}\right)\), which allows for complex \(n\) and \(x\).

We also have \(\displaystyle W_n(x) = U_{2n} \left( \sqrt{\frac{x+1}{2}} \right)\) for \(x \ge 0\), and \(W_n (x) = (-1)^n V_{n}(-x)\) for \(x < 0\).

For integer \(n\), the following recursion can be used, with \(W_{-n-1}(x) = -W_{n}(x)\):

\begin{eqnarray} W_0 (x) & = & 1 \\ W_1 (x) & = & 2x+1 \nonumber \\ W_{n+1} (x)& = & 2x W_{n}(x) - W_{n-1}(x). \nonumber \end{eqnarray}

See also Wikipedia [1405], MathWorld [988], NIST [419], Ehrhardt [309] (3.7.4).

An example in Python

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

An example in Visual Basic

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

Gegenbauer (ultraspherical) polynomial, \(C_{n}^{\alpha}(x)\)#

ctx.gegenbauer_c(n, alpha, x)#

where ctx is math53, ctxboost or ctxflint.

Returns \(\displaystyle C_n^{(a)}(z)\), the Gegenbauer polynomial of degree \(n\) with parameter \(a\). The Gegenbauer polynomials are orthogonal on the interval \((-1, 1)\), with respect to the weight function \(w(x) = (1 - x^2)^{a-1/2}\) .

If \(a \neq 0\) the function uses the recurrence formulas

\begin{eqnarray} C^{(a)}_0 (x) & = & 1 \\ C^{(a)}_1 (x) & = & 2ax \nonumber \\ nC^{(a)}_n (x)& = & 2(n+a-1)x C^{(a)}_{n-1}(x) - (n+2a-2) C^{(a)}_{n-2}(x). \nonumber \end{eqnarray}

For \(a = 0\) the result can be expressed in Chebyshev polynomials: \(\displaystyle C^{(0)}_0 (x) = 1, \quad C^{(0)}_n (x) = 2/n T_n(x)\).

See also Wikipedia [1410], MathWorld [994], NIST [419], BoostMath [126], Ehrhardt [309] (3.7.6), Flint [825], Flint [821], Mpmath [659].

The function can also be expressed as

\[C_n^{a}(z)=\frac{(2 a)_n}{\Gamma(n+1)} {}_2F_1\left(-n,2 a+n,a+\frac{1}{2},\frac{1-z}{2}\right).\]

For nonnegative integer n, this is a polynomial in a and z, even when the parameters are such that the hypergeometric series is undefined. In such cases, the polynomial is evaluated using direct methods.

An example in Python

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

An example in Visual Basic

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

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; n = '10' ; a = '7.0'; x = '5.0'
>>> \mathrm{d}x = dec.gegenbauer(n, a, x); mx = mpm.gegenbauer(n, a, x); gx = gmp.gegenbauer(n, a, x)
>>> fx = fpm.gegenbauer(n, a, x); ax = apm.gegenbauer(n, a, x)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  7.565898478553800000000000000000000000000E+13
mpm:  7.565898478553800000000000000000000000000e+13
gmp:  7.565898478553800000000000000000000000000E+13
fpm:  7.56589847855380E+13
apm:  7.565898478553800000000000000000000000000e+13 (2.135e-39%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; n = '10'; a = '7.0 + 1j'; z = '5.0 + 3j'
>>> \mathrm{d}z = dec.gegenbauer(n, a, z); mz = mpm.gegenbauer(n, a, z); gz = gmp.gegenbauer(n, a, z)
>>> fz = fpm.gegenbauer(n, a, z); az = apm.gegenbauer(n, a, z)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 3.8222147440285373854E+14              + 3.3043282427731541887E+13j
mpm: 3.8222147440285373854e+14              + 3.3043282427731541887e+13j
gmp: 3.8222147440285373854E+14              + 3.3043282427731541887E+13j
fpm: 3.82221474402854E+14                   + 3.30432824277315E+13j
apm: 3.8222147440285373854e+14 (6.238e-20%) + 3.3043282427731541887e+13 (2.255e-19%)j

Jacobi polynomials, \(P_{n}^{(a, b)}\)#

ctx.jacobi_p(n, a, b, x)#

where ctx is math53, ctxboost or ctxflint.

Returns \(\displaystyle P_n^{(a,b)}(x)\), the Jacobi polynomial of degree \(n \geq 0\) with parameters \((a, b)\), where \(a, b\) should be greater than \(-1\), and \(a + b\) must not be an integer less than \(-1\). Jacobi polynomials are orthogonal on the interval \((-1, 1)\), with respect to the weight function \(w(x) = (1 - x)^a (1 + x)^b\), if \(a, b\) are greater than \(-1\).

The cases \(n \leq 1\) are computed with the explicit formulas

\[P^{(a,b)}_0= 1, \quad 2P^{(a,b)}_1= (a - b) + (a + b + 2)x,\]

and for \(n > 1\) there are the somewhat complicated recurrence relations

\begin{eqnarray} P^{(a,b)}_{n+1} & = & (A_n x + B_n)P^{(a,b)}_n - C_n P^{(a,b)}_{n-1} \\ A_n & = & \frac{(2n + a + b + 1)(2n + a + b + 2)}{2(n + 1)(n + a + b + 1)} \nonumber \\ B_n & = & \frac{(a^2 - b^2 )(2n + a + b + 1)}{2(n + 1)(n + a + b + 1)(2n + a + b)} \nonumber \\ C_n & = & \frac{(n + a)(n + b)(2n + a + b + 2)}{(n + 1)(n + a + b + 1)(2n + a + b)} . \nonumber \end{eqnarray}

See also Wikipedia [1418], MathWorld [999], NIST [419], BoostMath [129], Ehrhardt [309] (3.7.9), Mpmath [664].

The function can also be expressed as

\[P_n^{(a,b)}(x)=\frac{(a+1)_n}{\Gamma(n+1)} {}_2F_1\left(-n,n+a+b+1,a+1,\frac{1-x}{2}\right).\]

For nonnegative integer n, this is a polynomial in a, b and z, even when the parameters are such that the hypergeometric series is undefined. In such cases, the polynomial is evaluated using direct methods.

An example in Python

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

An example in Visual Basic

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

An example with real input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 40; n = '10' ; a = '7.0'; b = '8.0'; x = '5.0'
>>> \mathrm{d}x = dec.jacobi(n, a, b, x); mx = mpm.jacobi(n, a, b, x); gx = gmp.jacobi(n, a, b, x)
>>> fx = fpm.jacobi(n, a, b, x); ax = apm.jacobi(n, a, b, x)
>>> mpm.show([\mathrm{d}x, mx, gx, fx, ax])
dec:  1.566492891288000000000000000000000000000E+12
mpm:  1.566492891288000000000000000000000000000e+12
gmp:  1.566492891288000000000000000000000000000E+12
fpm:  1.56649289128800E+12
apm:  1.566492891288000000000000000000000000000e+12 (1.611e-39%)

An example with complex input:

>>> from xlcalcnet import dec, mpm, gmp, fpm, apm
>>> mpm.dps = 20; n = '10'; a = '7.0 + 1j'; b = '8.0 + 2j'; z = '5.0 + 3j'
>>> \mathrm{d}z = dec.jacobi(n, a, b, z); mz = mpm.jacobi(n, a, b, z); gz = gmp.jacobi(n, a, b, z)
>>> fz = fpm.jacobi(n, a, b, z); az = apm.jacobi(n, a, b, z)
>>> mpm.show([\mathrm{d}z, mz, gz, fz, az],  aligned=True)
dec: 7.8001821589253876064E+12              + 1.0625055373536412146E+12j
mpm: 7.8001821589253876064e+12              + 1.0625055373536412146e+12j
gmp: 7.8001821589253876064E+12              + 1.0625055373536412146E+12j
fpm: 7.80018215892539E+12                   + 1.06250553735364E+12j
apm: 7.8001821589253876064e+12 (4.776e-20%) + 1.0625055373536412146e+12 (1.315e-19%)j

Zernike radial polynomials \(R_n^m(r)\)#

math53.zernike_r(n, m, r)#

Returns the Zernike radial polynomial \(R_n^m(r)\), with \(r \ge 0\), and \(n \ge m \ge 0\), \(n-m\) even, zero otherwise. The orthogonality relation is

\[\int_0^1 R_n^m(r) R_{n'}^m(r) r \, \mathrm{d}r = \frac{1}{2(n+1)} \delta_{nn'}.\]
\[R_n^m(r) = (-1)^{(n-m)/2} r^m P_{(n-m)/2}^{(m,0)}(1-2r^2) = r^m P_{(n-m)/2}^{(0,m)}(2r^2-1).\]

See also: http://mathworld.wolfram.com/ZernikePolynomial.html

See also https://en.wikipedia.org/wiki/Zernike_polynomials

See also Ehrhardt [309] (3.7.20).

An example in Python

>>> from xlcalcnet import xreal
>>> xreal.ZernikeR(4, 5, 0.5)
xreal('5.2359877559829887307E-1')
>>> xreal.ZernikeR(4, 5,'0.51')
xreal('5.3518479027559984754E-1')

An example in Visual Basic

>>> from xlcalcnet import Gpr
>>> Gpr.ZernikeR(4, 5, 0.5)
Gpr('5.2359877559829887307E-1')
>>> Gpr.ZernikeR(4, 5,'0.51')
Gpr('5.3518479027559984754E-1')
Contents