Evaluate a 2-D Laguerre series on the Cartesian product of x and y in Python

To evaluate a 2-D Laguerre series on the Cartesian product of x and y, use the polynomial.laguerre.laggrid2d() method in Python. The method returns the values of the two dimensional Laguerre series at points in the Cartesian product of x and y.

If c has fewer than two dimensions, ones are implicitly appended to its shape to make it 2-D. The shape of the result will be c.shape[2:] + x.shape + y.shape.

Syntax

numpy.polynomial.laguerre.laggrid2d(x, y, c)

Parameters

x, y: The two dimensional series is evaluated at the points in the Cartesian product of x and y. If x or y is a list or tuple, it is first converted to an ndarray, otherwise it is left unchanged and, if it isn't an ndarray, it is treated as a scalar.

c: Array of coefficients ordered so that the coefficient of the term of multi-degree i,j is contained in c[i,j]. If c has dimension greater than two, the remaining indices enumerate multiple sets of coefficients.

Example

Let's create a 2D array of coefficients and evaluate the Laguerre series ?

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

# Create a 2D array of coefficients
c = np.arange(4).reshape(2,2)

# Display the array
print("Our Array...")
print(c)

# Check the Dimensions
print("\nDimensions of our Array...")
print(c.ndim)

# Get the Datatype
print("\nDatatype of our Array object...")
print(c.dtype)

# Get the Shape
print("\nShape of our Array object...")
print(c.shape)

# Evaluate 2-D Laguerre series on the Cartesian product
print("\nResult...")
print(L.laggrid2d([1,2], [1,2], c))

Our Array...
[[0 1]
 [2 3]]

Dimensions of our Array...
2

Datatype of our Array object...
int64

Shape of our Array object...
(2, 2)

Result...
[[ 0. -1.]
 [-2.  0.]]

How It Works

The laggrid2d() method evaluates the 2-D Laguerre series using the formula:

L(x,y) = ? ? c[i,j] * L_i(x) * L_j(y)

Where L_i(x) and L_j(y) are the Laguerre polynomials of degree i and j respectively. The method computes this for all combinations of x and y values in the Cartesian product.

Example with Different Inputs

Let's see how different coefficient arrays affect the result ?

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

# Example with a simple coefficient matrix
c1 = np.array([[1, 0], [0, 1]])
print("Identity-like coefficients:")
print(c1)

# Evaluate at specific points
x_vals = [0, 1]
y_vals = [0, 1]
result1 = L.laggrid2d(x_vals, y_vals, c1)
print("\nResult with identity-like coefficients:")
print(result1)

# Example with different coefficients
c2 = np.array([[2, -1], [1, 3]])
print("\nDifferent coefficients:")
print(c2)

result2 = L.laggrid2d(x_vals, y_vals, c2)
print("\nResult with different coefficients:")
print(result2)

Identity-like coefficients:
[[1 0]
 [0 1]]

Result with identity-like coefficients:
[[ 1.  1.]
 [ 0. -1.]]

Different coefficients:
[[ 2 -1]
 [ 1  3]]

Result with different coefficients:
[[ 2.  2.]
 [ 1. -2.]]

Conclusion

The laggrid2d() method efficiently evaluates 2-D Laguerre series on Cartesian products of x and y coordinates. It's particularly useful in numerical analysis and scientific computing where Laguerre polynomials are needed for approximating functions or solving differential equations.