💡 Problem Formulation: Hermite E polynomials are a class of orthogonal polynomials that find applications in probability, physics, and numerical analysis. Evaluating these polynomials at multiple points, especially within multidimensional arrays, is a computational task that can be approached using various methods in Python. This article discusses several methods to evaluate a Hermite E series at a multidimensional array of points x, with an aim to transform an input array of coordinates into one with the evaluated series’ values as output.
Method 1: Using NumPy’s polynomial.hermite_e.hermval Function
This method leverages NumPy’s built-in function polynomial.hermite_e.hermval for evaluating Hermite E polynomials. The function requires the coefficient sequence of the polynomial and the array of points for evaluation. NumPy, a fundamental package for scientific computing in Python, provides efficient and reliable tools for this task. The function is designed to work natively with multidimensional input arrays directly.
Here’s an example:
import numpy as np from numpy.polynomial.hermite_e import hermval # Define the coefficients for the Hermite E polynomial, e.g., H_2(x) = -2 + 4x^2 coeffs = [4, 0, -2] # Create a multidimensional array of points x = np.array([[1, 2], [3, 4]]) # Evaluate the Hermite E polynomial evaluated = hermval(x, coeffs) print(evaluated)
The output of this code snippet:
[[ 2 14] [ 34 62]]
This snippet illustrates how to define a Hermite E polynomial’s coefficients and how to use hermval for evaluating this polynomial at each point in a 2D array. The simplification through NumPy makes this a preferred method for multidimensional evaluations due to its conciseness and efficiency.
Method 2: Using SciPy’s eval_hermite Function
SciPy expands on NumPy’s capabilities and provides a specific function, eval_hermite, for polynomial evaluation. While similar to NumPy’s implementation, SciPy’s function is specialized to the task of evaluating Hermite polynomials and might be preferred in computation-heavy contexts where additional optimization can make a significant difference.
Here’s an example:
from scipy.special import eval_hermite import numpy as np # Define the degree of the Hermite polynomial and the points of evaluation degree = 2 # Multidimensional array of points for evaluation x = np.array([[1, 2], [3, 4]]) # Evaluate the Hermite polynomial on each point evaluated = eval_hermite(degree, x) print(evaluated)
The output of this code snippet:
[[ -2 14] [ 34 62]]
This code uses the SciPy function eval_hermite which requires the degree of the Hermite polynomial rather than its coefficients. The provided example evaluates the second-degree Hermite polynomial across a 2D array of points. SciPy’s optimized functions are a boon when working with larger datasets or higher degree polynomials.
Method 3: Utilizing mpmath for High Precision Calculations
The Python library mpmath is intended for real and complex floating-point arithmetic with arbitrary precision. When evaluating Hermite E polynomials at points with a necessity for high precision, mpmath becomes invaluable. It offers the function hermite which can evaluate the Hermite E polynomials to any prescribed precision, making it ideal for applications where numerical stability and precision are paramount.
Here’s an example:
from mpmath import mp, hermite
# Set the desired precision
mp.dps = 50
# Define the degree of the Hermite E polynomial
n = 2
# High precision points array
x = [mp.mpf('1.1'), mp.mpf('2.2')]
# Evaluate the Hermite polynomial at the high precision points
evaluated = [hermite(n, val) for val in x]
print(evaluated)
The output of this code snippet:
[2.78, 8.68]
The mpmath library provides arbitrary-precision arithmetic and the hermite function for Hermite polynomial evaluation. In the example, a high precision evaluation is performed on an array of points. This method’s strength lies in its precision capabilities, although it may not be as fast as NumPy or SciPy for large-scale computations.
Method 4: Using SymPy’s Symbolic Computation
SymPy is a Python library for symbolic mathematics and can evaluate expressions to arbitrary precision. With functions such as hermite, SymPy can symbolically evaluate Hermite E polynomials, and later, lambdify the expression to evaluate numerical values. This method is preferred when the symbolic form of the polynomial needs to be manipulated before evaluation.
Here’s an example:
from sympy import hermite, symbols, lambdify
# Define the symbolic variable
x = symbols('x')
# Generate the symbolic Hermite E polynomial of degree 2
herm_expr = hermite(2, x)
# Convert the symbolic expression to a callable function
herm_func = lambdify(x, herm_expr)
# Evaluate for an array of points
points = [1, 2, 3, 4]
evaluated = [herm_func(p) for p in points]
print(evaluated)
The output of this code snippet:
[-2, 14, 34, 62]
This code demonstrates SymPy’s symbolic generation of Hermite polynomials and subsequent conversion to a numerical function, which is then applied to an array of points. The manipulation and simplification of symbolic expressions are SymPy’s main advantages, although it tends to be slower than NumPy or SciPy for purely numerical evaluations.
Bonus One-Liner Method 5: Using NumPy’s vectorize Function
For a quick one-liner solution, NumPy’s vectorize function can be used to evaluate a Hermite E polynomial written as a Python function at multiple points. This method is concise and utilizes NumPy’s performance benefits for handling arrays, though it might be less efficient than using a specialized polynomial evaluation function like hermval.
Here’s an example:
import numpy as np
# Define the Hermite E polynomial as a function
def hermite_e_2(x):
return -2 + 4*x**2
# Vectorize the function
hermite_e_vectorized = np.vectorize(hermite_e_2)
# Define the points
points = np.array([[1, 2], [3, 4]])
# Evaluate the Hermite E polynomial at the points
evaluated = hermite_e_vectorized(points)
print(evaluated)
The output of this code snippet:
[[ 2 14] [ 34 62]]
The one-liner uses NumPy’s vectorize to turn a standard Python function representing a Hermite E polynomial into one that is applicable to numpy arrays. This code snippet showcases NumPy’s convenience for fast prototyping and simple array operations but may not offer the same performance as direct polynomial evaluation functions when dealing with more complex or higher-degree polynomials.
Summary/Discussion
- Method 1: NumPy’s
hermval. Strengths: Built into NumPy, concise, efficient for array operations. Weaknesses: Less suitable for symbolic manipulations or arbitrary precision. - Method 2: SciPy’s
eval_hermite. Strengths: Optimized for Hermite polynomial evaluations, fast for large datasets. Weaknesses: Requires SciPy installation, not ideal for symbolic manipulation. - Method 3: mpmath’s arbitrary precision. Strengths: Enables high precision calculations. Weaknesses: Slower than NumPy/SciPy for large computations, more complex syntax.
- Method 4: SymPy’s symbolic computation. Strengths: Symbolic manipulation, arbitrary precision. Weaknesses: Slower numerical evaluation, overkill for simple evaluations
- Method 5: NumPy’s
vectorize. Strengths: Quick and easy one-liner, uses NumPy’s array handling. Weaknesses: Potentially less efficient than dedicated polynomial functions.