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
    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)?

Answer:

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

Common xlabel/ylabel for matplotlib subplots

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Why do I get "Pickle - EOFError: Ran out of input" reading an empty file?

12 answers

NUMPYNUMPY

Flake8: Ignore specific warning for entire file

12 answers

NUMPYNUMPY

glob exclude pattern

12 answers

NUMPYNUMPY

How to avoid HTTP error 429 (Too Many Requests) python

12 answers

NUMPYNUMPY

Python CSV error: line contains NULL byte

12 answers

NUMPYNUMPY

csv.Error: iterator should return strings, not bytes

12 answers

News


Wiki

Python | How to copy data from one Excel sheet to another

Common xlabel/ylabel for matplotlib subplots

Check if one list is a subset of another in Python

sin

How to specify multiple return types using type-hints

exp

Printing words vertically in Python

exp

Python Extract words from a given string

Cyclic redundancy check in Python

Finding mean, median, mode in Python without libraries

cos

Python add suffix / add prefix to strings in a list

Why do I get "Pickle - EOFError: Ran out of input" reading an empty file?

Python - Move item to the end of the list

Python - Print list vertically