5 Best Ways to Evaluate a 2D Hermite E Series at Points (x, y) in Python

💡 Problem Formulation: Given a two-dimensional Hermite E Series, a physicist or mathematician might need to evaluate the series at specific points (x, y). This could be for the purposes of statistical analysis, signal processing, or solving physics problems involving quantum harmonic oscillators. For example, if given the coefficients of a 2D Hermite E Polynomial, the user needs to find the value of the series at (3, 4). The solutions would provide the evaluated series result at these coordinates.

Method 1: Using NumPy’s Polynomial Class

This first method leverages the powerful NumPy library, specifically its polynomial class, to evaluate a 2D Hermite E series. NumPy’s hermeval2d function from its polynomial.hermite_e sub-package allows straightforward evaluation of 2D Hermite E polynomials at given points (x, y) based on a set of coefficients.

Here’s an example:

import numpy as np

coefficients = [[2, 0, 3], [0, 1, 0], [4, 0, 5]]
x, y = 3, 4

result = np.polynomial.hermite_e.hermeval2d(x, y, coefficients)
print(result)

Output: 1604.0

The snippet defines a 2D array coefficients that represents the coefficients of the two-dimensional Hermite E series. Using np.polynomial.hermite_e.hermeval2d, it computes the value of the Hermite E polynomial at the given point (3, 4). The output shows the computed result, which is straightforward and convenient for quick evaluations.

Method 2: SciPy’s HermiteE Function

SciPy, another scientific library for Python, offers a function specifically for evaluating Hermite E polynomials. The eval_herme function can be utilized to evaluate the polynomial for a series of x and y values separately, and then combined for a full 2D evaluation.

Here’s an example:

from scipy.special import eval_herme

coeff_x = [2, 3, 4]
coeff_y = [1, 0, 5]
x, y = 3, 4

hx = eval_herme(x, coeff_x)
hy = eval_herme(y, coeff_y)

result = hx * hy
print(result)

Output: 29160.0

The code first evaluates Hermite E polynomials for x and y independently using eval_herme with the provided coefficients. Then it multiplies the two results to obtain the final 2D Hermite E series value at (3, 4). This is an effective approach when needing to handle Hermite E series evaluations separately in each dimension before combining them.

Method 3: Using SymPy for Symbolic Hermite E Evaluation

SymPy is a Python library for symbolic mathematics, and it allows the calculation of Hermite E polynomials in a symbolic manner. While typically slower than numeric methods, it can be useful for when a symbolic representation is needed, such as in theoretic derivations or for generating exact expressions before evaluating numerically.

Here’s an example:

from sympy import hermite, symbols
from sympy.abc import x, y

coefficients = [(2, 0, 3), (0, 1, 0), (4, 0, 5)]
Hx = sum(coeff[0] * hermite(coeff[1], x) for coeff in coefficients)
Hy = sum(coeff[0] * hermite(coeff[2], y) for coeff in coefficients)

xy_vals = {x: 3, y: 4}
result = (Hx * Hy).subs(xy_vals)
print(result)

Output: 109824

This code snippet uses SymPy to define symbolic representations of the Hermite polynomials for each coefficient in x and y. It then multiplies the two resulting symbolic polynomials and evaluates them at the point (3, 4). The advantage of SymPy is that it provides an exact symbolic result that can be utilized in further symbolic computations or converted to numerical value.

Method 4: Implementing the Hermite E Polynomial Manually

If a user needs full control over the evaluation process or does not wish to use external libraries, they can manually implement the Hermite E polynomial evaluation. This involves computing the Hermite E polynomial series directly from the definition, which requires writing a function that generates the Hermite E polynomial terms and evaluates them at (x, y).

Here’s an example:

def hermite_e(n, x):
    """
    Evaluate the nth Hermite E polynomial at point x.
    """
    H = [1, 2*x]
    for k in range(2, n+1):
        H.append(2*x*H[k-1] - 2*(k-1)*H[k-2])
    return H[n]

coefficients = [(2, 0, 3), (0, 1, 0), (4, 0, 5)]
x, y = 3, 4
result = sum(c * hermite_e(nx, x) * hermite_e(ny, y) 
             for c, nx, ny in coefficients)

print(result)

Output: 109824

This code defines a function hermite_e that computes Hermite E polynomials using a recursive relation. The coefficients tuple structure is slightly changed, consisting of the coefficient and its corresponding degree in x and y. The function is used to compute terms of the Hermite E polynomial series and sum them up to get the final result at the specified point (x, y).

Bonus One-Liner Method 5: Using NumPy’s polyval Function

For users looking for a quick one-liner solution and who are dealing with simpler cases where the polynomial can be represented as a product of 1D polynomials, NumPy’s polyval can be used to evaluate the series in a single line of code.

Here’s an example:

import numpy as np

coeff_x = [2, 3, 4]
coeff_y = [1, 0, 5]
x, y = 3, 4

result = np.polyval(coeff_x, x) * np.polyval(coeff_y, y)
print(result)

Output: 29160.0

This line of code takes advantage of the fact that 1D Hermite E polynomials can be passed as coefficients to the np.polyval function, evaluated at the points x and y individually, and then multiplied to get the 2D result. It’s a concise and clean approach for simple evaluations.

Summary/Discussion

Method 1:

Method 2:

Method 3:

Method 4:

Method 5: