Generate a Pseudo Vandermonde matrix of the Legendre polynomial and x, y array of points in Python

To generate a pseudo Vandermonde matrix of the Legendre polynomial, use the legendre.legvander2d() method in NumPy. This method creates a 2D pseudo-Vandermonde matrix where each column represents evaluations of Legendre polynomial basis functions at given coordinate points.

The method returns a matrix with shape x.shape + (deg + 1,), where the last index corresponds to the degree of the Legendre polynomial. The parameters x and y are arrays of point coordinates with the same shape, and deg is a list specifying maximum degrees as [x_deg, y_deg].

Basic Example

Let's create coordinate arrays and generate the pseudo Vandermonde matrix ?

import numpy as np
from numpy.polynomial import legendre as L

# Create coordinate arrays
x = np.array([1, 2])
y = np.array([3, 4])

print("X coordinates:", x)
print("Y coordinates:", y)
print("Array shapes:", x.shape, y.shape)

# Generate pseudo Vandermonde matrix
x_deg, y_deg = 2, 3
result = L.legvander2d(x, y, [x_deg, y_deg])
print("\nPseudo Vandermonde Matrix:")
print(result)

X coordinates: [1 2]
Y coordinates: [3 4]
Array shapes: (2,) (2,)

Pseudo Vandermonde Matrix:
[[  1.   3.  13.  63.   1.   3.  13.  63.   1.   3.  13.  63.]
 [  1.   4.  23.5 154.   2.   8.  47. 308.   5.5  22. 129.25 847.]]

Understanding the Matrix Structure

The resulting matrix has dimensions based on the input arrays and polynomial degrees ?

import numpy as np
from numpy.polynomial import legendre as L

x = np.array([1, 2])
y = np.array([3, 4])
x_deg, y_deg = 2, 3

result = L.legvander2d(x, y, [x_deg, y_deg])

print("Input array shapes:")
print(f"x.shape: {x.shape}")
print(f"y.shape: {y.shape}")

print(f"\nPolynomial degrees: x_deg={x_deg}, y_deg={y_deg}")
print(f"Expected columns: (x_deg+1) * (y_deg+1) = {(x_deg+1) * (y_deg+1)}")

print(f"\nResulting matrix shape: {result.shape}")
print(f"Number of points: {len(x)}")
print(f"Number of basis functions: {result.shape[1]}")

Input array shapes:
x.shape: (2,)
y.shape: (2,)

Polynomial degrees: x_deg=2, y_deg=3
Expected columns: (x_deg+1) * (y_deg+1) = 12

Resulting matrix shape: (2, 12)
Number of points: 2
Number of basis functions: 12

Different Polynomial Degrees

You can adjust the polynomial degrees to control the matrix dimensions ?

import numpy as np
from numpy.polynomial import legendre as L

x = np.array([0, 1, 2])
y = np.array([1, 2, 3])

# Different degree combinations
degrees = [(1, 1), (2, 1), (1, 2)]

for x_deg, y_deg in degrees:
    result = L.legvander2d(x, y, [x_deg, y_deg])
    print(f"Degrees [{x_deg}, {y_deg}]: Matrix shape {result.shape}")
    print(f"Columns: {(x_deg+1) * (y_deg+1)}")
    print()

Degrees [1, 1]: Matrix shape (3, 4)
Columns: 4

Degrees [2, 1]: Matrix shape (3, 6)
Columns: 6

Degrees [1, 2]: Matrix shape (3, 6)
Columns: 6

Working with Complex Numbers

The method handles complex coordinate arrays automatically ?

import numpy as np
from numpy.polynomial import legendre as L

# Complex coordinate arrays
x = np.array([1+0j, 2+1j])
y = np.array([0+1j, 1+0j])

print("Complex coordinates:")
print("x =", x)
print("y =", y)
print("x dtype:", x.dtype)

result = L.legvander2d(x, y, [1, 1])
print("\nPseudo Vandermonde matrix:")
print(result)
print("Result dtype:", result.dtype)

Complex coordinates:
x = [1.+0.j 2.+1.j]
y = [0.+1.j 1.+0.j]
x dtype: complex128

Pseudo Vandermonde matrix:
[[1.+0.j 0.+1.j 1.+0.j 0.+1.j]
 [1.+0.j 1.+0.j 2.+1.j 2.+1.j]]
Result dtype: complex128

Key Points

• Matrix shape is x.shape + ((x_deg+1) * (y_deg+1),)
• Each row corresponds to a coordinate point
• Each column represents a Legendre polynomial basis function
• Supports both real and complex coordinate arrays
• Useful for polynomial fitting and approximation tasks

Conclusion

The legendre.legvander2d() method efficiently generates pseudo Vandermonde matrices for 2D Legendre polynomial basis functions. This is essential for polynomial interpolation and fitting applications in computational mathematics.