# 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
else:
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))
```

### Output:

```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`.

## numpy.polynomial.legendre.legmulx

polynomial.legendre.legmulx(c)[source]

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

### Examples:

```from numpy.polynomial import legendre as L
L.legmulx([1,2,3])
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.

## Shop 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

NUMPYNUMPY

psycopg2: insert multiple rows with one query

NUMPYNUMPY

How to convert Nonetype to int or string?

NUMPYNUMPY

How to specify multiple return types using type-hints

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

## Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () 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