Change language

Python polynomials — Legendre using recursion relation

| | |

Legendre polynomials are a type of orthogonal polynomials that occur frequently in science and engineering. Therefore, its generation is crucial for these fields. There are different ways to evaluate a Legendre polynomial, using generator functions, Rodrigues formula, recurrence relation, Gram-Schmidt orthogonalization, etc. one of the most accurate methods is to use the recurrence relation.

Here we use the Bonnet recurrence relation of legendre polynomials:

We define Legendre polynomials as a function called P(n,x), where n is called the order of the polynomial and x is the evaluation point. The base cases are if n is 0, then The polynomial value is always 1, and it is x when the order is 1. These are the initial values ​​needed for the recurrence relation.

For other values ​​of n, the function is defined recursively, directly from the Bonnet recurrence. Thus, P(n, x) returns values ​​from the Legendre polynomial, by the recursion method (A function effectively defined with other base cases of the same function.)

# Legendre polynomial
def P(n, x): 
    if(n == 0):
        return 1 # P0 = 1
    elif(n == 1):
        return x # P1 = x
        return (((2 * n)-1)*x * P(n-1, x)-(n-1)*P(n-2, x))/float(n)
# Suppose, we want to find the value of 
# 3rd order legendre polynomial at x = 5
# We can display the value by--
# Driver program
n = 3
X = 5
print("The value of the polynomial at given point is:", P(n, X))


The value of the polynomial at given point is: 305.0

Recursion of integrated Legendre polynomials

StackOverflow question

I am writing these recursion in python and don’t get why the official solution is different than mine. The trivial cases for n = 1, 2 are clear. This is my approach:

return ((2*(k-1)-1)*x*leg(k-1) - ((k-1)-2)*leg(k-2)) / k

This is the official solution:

return ((2*k-1)*x*leg(k-1) - (k-1)*leg(k-2)) / k

Why are they decreasing k to call the function, but in the first part the coefficient (2*k-1) not? And why is the coefficient in the second part changed to (k-1)?


So generally, afaiu, your issue stems from the formula (in your attached image does show L_{k+1}(x)) while they do implement L_{k}(x) without the intermediate derivation that shows how to obtain L_{k}(x) from L_{k+1}(x).

I further think that there is some confusion here, so I will sightly deviate from the notation. Let m = k+1 in what follows.

We then obtain through straight forward substitution:

m * L(x, m) = (2*(m+1)-1) * x * L(x, m-1) - ((m-1)-2) * L(x, m-2)  # for m >= 3

which yields

L(x, m) = ( (2*m + 2 - 1) * x * L(x, m-1) - ((m-3) * L(x, m-2) ) / m

and in python syntax, this is:

def L(x, m):
    if m == 1:
        return x
    elif m == 2:
        return 0.5 * (x**2 - 1)
    else:  # do this for all m >= 3
        return ( (2*m + 1) * x * L(x, m-1) - ((m-3) * L(x, m-2) ) / m

Why are they decreasing k to call the function, but in the first part the coefficient (2*k-1) not?

IMHO they did, follow my derivation.

And why is the coefficient in the second part changed to (k-1)?

I honestly do not know; to me, it seems like they made a mistake during substitution, i.e. they must have put m+1 instead of m-1.

>>> (2*(k-1)-1)

Does first compute k-1 multiplies it by 2 and then subtracts 1 which is indifferent from 2*k-1. For example:

k = 5 does yield with your solution (2*(5-1)-1) = 7 and from the official solution (2*5-1) = 9.



Multiply a Legendre series by x. Multiply the Legendre series c by x, where x is the independent variable.


from numpy.polynomial import legendre as L
array([ 0.66666667, 2.2, 1.33333333, 1.8]) # may vary

Legendre polynomials in recurrent neural networks

A recurrent neural network that contains a d-dimensional memory vector, can be optimized such that its neural activities obey the linear time-invariant system given by the following state-space representation:

In this case, the sliding window of u across the past theta units of time is best approximated by a linear combination of the first {displaystyle d}d shifted Legendre polynomials, weighted together by the elements of m at time t:

When combined with deep learning methods, these networks can be trained to outperform long short-term memory units and related architectures, while using fewer computational resources.


Learn programming in R: courses


Best Python online courses for 2022


Best laptop for Fortnite


Best laptop for Excel


Best laptop for Solidworks


Best laptop for Roblox


Best computer for crypto mining


Best laptop for Sims 4


Latest questions


psycopg2: insert multiple rows with one query

12 answers


How to convert Nonetype to int or string?

12 answers


How to specify multiple return types using type-hints

12 answers


Javascript Error: IPython is not defined in JupyterLab

12 answers



Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method