Wolfram Language & System Documentation Center

LegendreP

LegendreP[n,x]

gives the Legendre polynomial .

LegendreP[n,m,x]

gives the associated Legendre polynomial .

Details

Mathematical function, suitable for both symbolic and numerical manipulation.
Explicit formulas are given for integers n and m.
The Legendre polynomials satisfy the differential equation .
The Legendre polynomials are orthogonal with unit weight function.
The associated Legendre polynomials are defined by $TemplateBox[{n, m, x}, LegendreP3]=(-1)^m(1-x^2)^(m/2)(d^m/dx^m)TemplateBox[{n, x}, LegendreP]$ .
For arbitrary complex values of n, m, and z, LegendreP[n,z] and LegendreP[n,m,z] give Legendre functions of the first kind.
LegendreP[n,m,a,z] gives Legendre functions of type a. The default is type 1.
The symbolic form of type 1 involves , of type 2 involves , and of type 3 involves .
Type 1 is defined only for within the unit circle in the complex plane. Type 2 represents an analytic continuation of type 1 outside the unit circle.
Type 2 functions have branch cuts from to and from to in the complex plane.
Type 3 functions have a single branch cut from to .
LegendreP[n,m,a,z] is defined to be Hypergeometric2F1Regularized[-n,n+1,1-m,(1-z)/2] multiplied by for type 2 and by for type 3.
For certain special arguments, LegendreP automatically evaluates to exact values.
LegendreP can be evaluated to arbitrary numerical precision.
LegendreP automatically threads over lists.
LegendreP can be used with Interval and CenteredInterval objects. »

Examples

open all close all

Basic Examples (6)

Evaluate numerically:

Wolfram Language code: LegendreP[2.5, 2]

Compute the Legendre polynomial:

Wolfram Language code: LegendreP[10, x]

Plot over a subset of the reals:

Wolfram Language code: Plot[LegendreP[1 / 2, x], {x, -1, 1}]

Plot over a subset of the complexes:

Wolfram Language code: ComplexPlot3D[LegendreP[1 / 2, z], {z, -2 - 2I, 2 + 2I}, PlotLegends -> Automatic]

Series expansion at the origin:

Wolfram Language code: Series[LegendreP[1 / 2, x], {x, 0, 2}]

Asymptotic expansion at Infinity:

Wolfram Language code: Series[LegendreP[1 / 2, x], {x, ∞, 3}]//Normal//FullSimplify

Scope (50)

Numerical Evaluation (7)

Evaluate numerically at fixed points:

Wolfram Language code: {LegendreP[2, 2], LegendreP[2, 2, 2], LegendreP[1.5, 2]}

Evaluate to high precision:

Wolfram Language code: N[LegendreP[3 / 2, 2], 50]

The precision of the output tracks the precision of the input:

Wolfram Language code: LegendreP[3 / 2, 2.000000000000000000000000000]

Evaluate for complex orders and arguments:

Wolfram Language code: LegendreP[3 / 2 + I, 1.5 - I]

Evaluate LegendreP efficiently at high precision:

Wolfram Language code: LegendreP[3 / 2, 2`300]//Timing

Wolfram Language code: LegendreP[3 / 2, 2`3000];//Timing

LegendreP can deal with real-valued intervals:

Wolfram Language code: LegendreP[3, Interval[{-0.5, 0.5}]]

Compute worst-case guaranteed intervals using Interval and CenteredInterval objects:

Wolfram Language code: LegendreP[1 / 2, 2 / 3, Interval[{0.4, 0.5}]]

Wolfram Language code: LegendreP[1 / 2, CenteredInterval[2, 1 / 100]]

Wolfram Language code: LegendreP[1 / 2, 2 / 3, CenteredInterval[2, 1 / 100]]

Or compute average-case statistical intervals using Around:

Wolfram Language code: LegendreP[2, Around[3, 0.5]]

Compute the elementwise values of an array:

Wolfram Language code: LegendreP[1, {{5 / 6, 0}, {1 / 2, -1 / 3}}]

Or compute the matrix LegendreP function using MatrixFunction:

Wolfram Language code: MatrixFunction[LegendreP[2, #]&, {{5 / 6, 0}, {1 / 2, -1 / 3}}]

Specific Values (5)

Legendre polynomial for symbolic :

Wolfram Language code: LegendreP[n, 0]//FunctionExpand

Wolfram Language code: LegendreP[n, 1]

Find a local maximum as a root of :

Wolfram Language code: xmax = Solve[D[LegendreP[5, x], x] == 0 && 0 < x < 0.5, x][[1, 1, 2]]

Wolfram Language code: Plot[LegendreP[5, x], {x, -1, 1}, Epilog -> Style[Point[{xmax, LegendreP[5, xmax]}], PointSize[Large], Red]]

Compute the associated Legendre polynomial :

Wolfram Language code: LegendreP[10, 2, x]

Compute an associated Legendre polynomial for half-integer and :

Wolfram Language code: LegendreP[3 / 2, 1 / 2, x]

Different LegendreP types give different symbolic forms:

Wolfram Language code: Table[LegendreP[2, 1, a, z], {a, 1, 3}]

Visualization (3)

Plot the LegendreP function for various orders:

Wolfram Language code: Plot[{LegendreP[1, x], LegendreP[2, x], LegendreP[3, x], LegendreP[4, x]}, {x, -1, 1}]

Plot the real part of :

Wolfram Language code: ComplexContourPlot[Re[LegendreP[3, z]], {z, -3 - 3 I, 3 + 3 I}, IconizedObject[«PlotOptions»]]

Plot the imaginary part of :

Wolfram Language code: ComplexContourPlot[Im[LegendreP[3, z]], {z, -3 - 3 I, 3 + 3 I}, IconizedObject[«PlotOptions»]]

Type 2 and 3 of Legendre functions have different branch cut structures:

Wolfram Language code: Plot3D[Im[LegendreP[2, 1, 2, x + I y]], {x, -1.5, 1.5}, {y, -0.5, 0.5}, Exclusions -> {{y == 0, Abs[x] > 1}}]

Wolfram Language code: Plot3D[Im[LegendreP[2, 1, 3, x + I y]], {x, -1.5, 1.5}, {y, -0.5, 0.5}, Exclusions -> {{y == 0, -1 < x < 1}}]

Function Properties (12)

is defined for all for integer and for for noninteger :

Wolfram Language code: FunctionDomain[LegendreP[n, z], z]

In the complex plane, it is defined for when is not an integer:

Wolfram Language code: FunctionDomain[LegendreP[n, z], z, Complexes]

The associated Legendre function is additionally undefined at when is not an even integer:

Wolfram Language code: FunctionDomain[LegendreP[n, m, z], z, Complexes]

The range for Legendre polynomials of integer orders:

Wolfram Language code:

{FunctionRange[LegendreP[1, x], x, y], FunctionRange[LegendreP[2, x], x, y], FunctionRange[LegendreP[3, x], x, y], FunctionRange[LegendreP[4, x], x, y]}

The range for complex values is the whole plane:

Wolfram Language code:

{FunctionRange[LegendreP[1, z], z, y, Complexes], FunctionRange[LegendreP[2, z], z, y, Complexes], FunctionRange[LegendreP[3, z], z, y, Complexes], FunctionRange[LegendreP[4, z], z, y, Complexes]}

Legendre polynomial of an odd order is odd:

Wolfram Language code: LegendreP[1, -x] == -LegendreP[1, x]

Legendre polynomial of an even order is even:

Wolfram Language code: LegendreP[2, -x] == LegendreP[2, x]

Legendre polynomials have the mirror property :

Wolfram Language code: {LegendreP[1, Conjugate[z]] == Conjugate[LegendreP[1, z]], LegendreP[2, Conjugate[z]] == Conjugate[LegendreP[2, z]]}

is an analytic function of for integer :

Wolfram Language code: FunctionAnalytic[LegendreP[n, x], x, Assumptions -> n∈ℤ]

It is neither analytic nor meromorphic for noninteger :

Wolfram Language code: FunctionAnalytic[LegendreP[1 / 2, x], x]

Wolfram Language code: FunctionMeromorphic[LegendreP[1 / 2, x], x]

The associated Legendre function is analytic as long as is also an even integer:

Wolfram Language code: FunctionAnalytic[LegendreP[n, m, x], x, Assumptions -> {n, (m/2)}∈ℤ]

is neither non-decreasing nor non-increasing for integers :

Wolfram Language code: Table[FunctionMonotonicity[LegendreP[n, x], x], {n, 0, 5}]

is neither non-decreasing nor non-increasing for integers :

Wolfram Language code: Table[FunctionInjective[LegendreP[n, x], x], {n, 5}]

Wolfram Language code: Plot[{LegendreP[2, x], LegendreP[3, x], LegendreP[4, x], 1 / 4}, {x, -2, 2}, PlotRange -> 1]

is surjective for positive odd integer values of but not even values:

Wolfram Language code: Table[FunctionSurjective[LegendreP[n, x], x], {n, 4}]

Wolfram Language code: Plot[{LegendreP[1, x], LegendreP[2, x], LegendreP[3, x], LegendreP[4, x], -1}, {x, -2, 2}, PlotRange -> 2]

LegendreP is neither non-negative nor non-positive:

Wolfram Language code: Table[FunctionSign[LegendreP[n, x], x], {n, 4}]

has no singularities or discontinuities when is an integer:

Wolfram Language code: FunctionSingularities[LegendreP[n, x], x]

Wolfram Language code: FunctionDiscontinuities[LegendreP[n, x], x]

The associated Legendre function has additional singularities when is not an even integer:

Wolfram Language code: FunctionSingularities[LegendreP[n, m, x], x]

is neither non-decreasing nor non-increasing for integers :

Wolfram Language code: Table[FunctionConvexity[LegendreP[n, x], x], {n, 5}]

Differentiation (3)

First derivative:

Wolfram Language code: D[LegendreP[n, x], x]

Higher derivatives:

Wolfram Language code: derivs = Table[D[LegendreP[n, x], {x, l}], {l, 1, 4}]//FullSimplify

Plot higher derivatives for :

Wolfram Language code:

Plot[Evaluate[derivs /. n -> 5], {x, -1, 1}, PlotRange -> {-50, 50}, PlotLegends -> {"First Derivative", "Second Derivative", "Third Derivative", "Fourth Derivative"}]

Formula for the derivative:

Wolfram Language code: D[LegendreP[n, x], {x, l}]

Integration (3)

Indefinite integral of LegendreP:

Wolfram Language code: Integrate[LegendreP[n, x], x]

Indefinite integral of an algebraic function with :

Wolfram Language code: Integrate[(1 - x^2)^(-3 - n/2)LegendreP[n, x], x]

Definite integral of :

Wolfram Language code: Integrate[LegendreP[n, x], {x, -1, 1}]

Series Expansions (4)

Taylor expansion for :

Wolfram Language code: Series[LegendreP[n, x], {x, 0, 5}]//FullSimplify

Plot the first three approximations for at :

Wolfram Language code:

terms = Normal@Table[Series[LegendreP[7, x], {x, 0, m}], {m, 1, 5, 2}];
Plot[{LegendreP[7, x], terms}, {x, -1, 1}, PlotRange -> {-1, 1}]

General term in the series expansion of :

Wolfram Language code: SeriesCoefficient[LegendreP[n, x], {x, 0, l}]//FullSimplify

Taylor expansion for the associated Legendre polynomial :

Wolfram Language code: Series[LegendreP[n, m, x], {x, 0, 1}]//FullSimplify

LegendreP can be applied to a power series:

Wolfram Language code: LegendreP[3 / 2, 1 / 2, Sin[x] + O[x] ^ 5]

Integral Transforms (4)

The Fourier transform of a Legendre polynomial with order using FourierTransform:

Wolfram Language code: FourierTransform[LegendreP[2, t], t, ω ]

The Laplace transform of a Legendre polynomial with order using LaplaceTransform:

Wolfram Language code: LaplaceTransform[LegendreP[3, t], t, s ]

The Mellin transform of a Legendre polynomial with order using MellinTransform:

Wolfram Language code: MellinTransform[LegendreP[3, x], x, s ]

The Hankel transform of a Legendre polynomial with order using HankelTransform:

Wolfram Language code: HankelTransform[LegendreP[1, x], x, s ]

Function Identities and Simplifications (4)

LegendreP may reduce to simpler functions:

Wolfram Language code: LegendreP[(3/4), (1/4), 2, x]//Together

Associated Legendre polynomials in terms of ordinary Legendre polynomials:

Wolfram Language code: FullSimplify[(-1)^m(1 - x^2)^m / 2D[LegendreP[n, x], {x, m}], Element[m, Integers]]

Sum of Legendre polynomials:

Wolfram Language code: Sum[LegendreP[n, x]t^n, {n, 0, Infinity}]

Recurrence relation:

Wolfram Language code: (n + 1) LegendreP[n + 1, z] == (2 n + 1) z LegendreP[n, z] - n LegendreP[n - 1, z]//FullSimplify

Function Representations (5)

Representation in terms of MeijerG:

Wolfram Language code: LegendreP[n, x] == -(1/π)Limit[Sin[π ν]MeijerG[{{ν + 1, -ν}, {}}, {{0}, {0}}, (x - 1/2)], ν -> n]//FullSimplify

LegendreP can be expressed as a DifferentialRoot:

Wolfram Language code: DifferentialRootReduce[LegendreP[n, x], x]

SphericalHarmonicY uses associated Legendre function in its definition:

Wolfram Language code:

FullSimplify[SphericalHarmonicY[n, m, θ, ϕ] == Sqrt[(2n + 1) / (4π)]Sqrt[(n - m)! / (n + m)!]LegendreP[n, m, Cos[θ]]Exp[I m ϕ], Element[m, Integers] && -n ≤ m ≤ n]//PowerExpand

Associated Legendre polynomials in terms of the angular spheroidal function:

Wolfram Language code: SpheroidalPS[n, m, 0, z]//FullSimplify

TraditionalForm formatting:

Wolfram Language code: LegendreP[n, z]//TraditionalForm

Wolfram Language code: LegendreP[n, m, z]//TraditionalForm

Generalizations & Extensions (3)

LegendreP can deal with real-valued intervals:

Wolfram Language code: LegendreP[3, Interval[{-1, 1}]]

Different LegendreP types give different symbolic forms:

Wolfram Language code: LegendreP[2, 1, 1, z]

Wolfram Language code: LegendreP[2, 1, 2, z]

Wolfram Language code: LegendreP[2, 1, 3, z]

Types 2 and 3 have different branch cut structures:

Wolfram Language code: Plot3D[Im[LegendreP[2, 1, 2, x + I y]], {x, -1.5, 1.5}, {y, -0.5, 0.5}, Exclusions -> {{y == 0, Abs[x] > 1}}]

Wolfram Language code: Plot3D[Im[LegendreP[2, 1, 3, x + I y]], {x, -1.5, 1.5}, {y, -0.5, 0.5}, Exclusions -> {{y == 0, -1 < x < 1}}]

Applications (5)

Angular momentum eigenfunctions:

Wolfram Language code: DSolve[Sin[θ] D[Sin[θ] f'[θ], θ] - m^2f[θ] == -λ(λ + 1)Sin[θ]^2f[θ], f[θ], θ]

The Pöschl–Teller potential is a special class of potentials for which the one-dimensional Schrödinger equation can be solved in terms of special functions.

Find quantum eigenfunctions for the modified Pöschl–Teller potential:

Wolfram Language code: DSolve[-f''[x] - j(j + 1) / Cosh[x] ^ 2 f[x] == -n ^ 2 f[x], f[x], x]

A -analog of the Legendre polynomial can be defined in terms of QHypergeometricPFQ:

Wolfram Language code: qLegendreP[n_, θ_, q_] := QHypergeometricPFQ[{q^-n, q^n + 1, q^1 / 4E^I θ, q^1 / 4E^-I θ}, {q, -q, -q^1 / 2}, q, q]

Wolfram Language code: qLegendreP[2, θ, q]//FunctionExpand//ExpToTrig//Simplify

Recover the Legendre polynomial as :

Wolfram Language code: Limit[%, q -> 1]

Wolfram Language code: LegendreP[2, Cos[θ]]//Simplify

Generalized Fourier transform for functions on the interval -1 to 1:

Wolfram Language code: Table[(n + 1 / 2)Integrate[LegendreP[n, x]Sin[Pi x], {x, -1, 1}], {n, 0, 3}]

Wolfram Language code: Plot[ {Sin[Pi x], %.Table[LegendreP[n - 1, x], {n, Length[%]}]}, {x, -1, 1}]

An n-point Gaussian quadrature rule is based on the roots of the n-order Legendre polynomial. Compute the nodes and weights of an n-point Gaussian quadrature rule:

Wolfram Language code:

n = 9;
lp[x_] = LegendreP[n, x];
gaussNodes = x /. NSolve[lp[x], x]

Wolfram Language code:

w1 = x |-> (2/n LegendreP[n - 1, x]lp'[x]);
gaussWeights = w1[gaussNodes]

Use the n-point Gaussian quadrature rule to numerically evaluate an integral:

Wolfram Language code: fun[x_] := (1/1 / 100 + (x - 3 / 10)^2) + (1/1 / 25 + (x - 9 / 10)^2) - 6

Wolfram Language code:

a = 1 / 2;b = 1;
est1 = ((b - a/2)gaussWeights).Map[fun, Rescale[gaussNodes, {-1, 1}, {a, b}]]

Compare the result of the Gaussian quadrature with the result from NIntegrate:

Wolfram Language code: est1 - NIntegrate[fun[x], {x, a, b}]

Properties & Relations (4)

Use FunctionExpand to expand into simpler functions:

Wolfram Language code: FunctionExpand[LegendreP[(3/4), (1/4), 2, x]]

LegendreP can be expressed as a DifferenceRoot:

Wolfram Language code: DifferenceRootReduce[LegendreP[k, y, z], k]

Wolfram Language code: DifferenceRootReduce[LegendreP[2, 2, k], k]

The generating function for LegendreP:

Wolfram Language code: GeneratingFunction[LegendreP[n, k], n, x]

The exponential generating function for LegendreP:

Wolfram Language code: ExponentialGeneratingFunction[LegendreP[n, k], n, x]

Possible Issues (1)

Cancellations in the polynomial form may lead to inaccurate numerical results:

Wolfram Language code: LegendreP[60, 1, x] /. x -> N[2 / 3, 16]

Evaluate the function directly:

Wolfram Language code: LegendreP[60, 1, N[2 / 3, 16] ]

Neat Examples (3)

Visualize distribution of zeros:

Wolfram Language code: ListPlot[Flatten[Table[{n, x} /. NSolve[LegendreP[n, x] == 0, x], {n, 1, 40}], 1], Axes -> False, Frame -> True]

Generalized Lissajous figures:

Wolfram Language code: ParametricPlot[ {LegendreP[7, x], LegendreP[13, x]}, {x, -1, 1}]

An expression for the Legendre polynomial in terms of the Hilbert matrix:

Wolfram Language code:

myLegendre[n_, x_] := (-1)^nBinomial[2n, n]FromDigits[Prepend[Reverse[LinearSolve[HilbertMatrix[n], -(1/Range[n + 1, 2n])]], 1], (1 - x/2)]

Verify the expression for the first few cases:

Wolfram Language code: Table[myLegendre[n, x] == LegendreP[n, x]//Simplify, {n, 20}]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

LegendreP

Details

Examples

Basic Examples (6)

Scope (50)

Numerical Evaluation (7)

Specific Values (5)

Visualization (3)

Function Properties (12)

Differentiation (3)

Integration (3)

Series Expansions (4)

Integral Transforms (4)

Function Identities and Simplifications (4)

Function Representations (5)

Generalizations & Extensions (3)

Applications (5)

Properties & Relations (4)

Possible Issues (1)

Neat Examples (3)

Text

CMS

APA

BibTeX

BibLaTeX

LegendreP

Details

Examples

Basic Examples (6)

Scope (50)

Numerical Evaluation (7)

Specific Values (5)

Visualization (3)

Function Properties (12)

Differentiation (3)

Integration (3)

Series Expansions (4)

Integral Transforms (4)

Function Identities and Simplifications (4)

Function Representations (5)

Generalizations & Extensions (3)

Applications (5)

Properties & Relations (4)

Possible Issues (1)

Neat Examples (3)

See Also

Tech Notes

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX