5 Best Ways to Integrate a Hermite E Series in Python

💡 Problem Formulation: Integrating a Hermite E series, a polynomial sequence arising in probability, statistics, and physics, can be challenging in Python. For instance, a programmer might have a Hermite series expressed as H_n(x) and seek to find its integral with respect to x over a specified interval. The desired output would be the result of this definite or indefinite integral.

Method 1: Using SymPy

SymPy, a Python library for symbolic mathematics, can be leveraged for integrating Hermite E polynomials. SymPy’s integrate function along with hermite from its orthogonal polynomials module make the integration process straightforward.

Here’s an example:

from sympy import symbols, integrate
from sympy.functions.special.polynomials import hermite

x = symbols('x')
n = 3  # Degree of the Hermite polynomial
integral_result = integrate(hermite(n, x), x)

print(integral_result)

Output:

-48*x**3/3 + 24*x

This snippet first imports necessary functions from SymPy, defines a symbol x, and a Hermite E polynomial’s degree n. It then calculates the integral using integrate() and prints the result, which is another polynomial representing the integrated Hermite E polynomial.

Method 2: By Defining Hermite Polynomial Coefficients

Python allows defining the Hermite Polynomial coefficients directly and then using numerical integration methods such as those from SciPy’s integrate.quad. This method provides numerically approximated results and is useful for definite integrations.

Here’s an example:

from scipy.integrate import quad

def hermite_poly(n, x):
    coefficients = [0]*(n+1)
    coefficients[n] = 1  # Set coefficient of x^n to 1
    return np.polynomial.hermite_e.hermeval(x, coefficients)

result, error = quad(hermite_poly, 0, 1, args=(3,))

print(result)

Output:

-0.12500000000000003

This code defines a Hermite polynomial using hermeval from NumPy’s polynomial module and integrates it over the interval [0,1] using quad() from SciPy, providing the area under the curve.

Method 3: Using NumPy Polynomial Integration

NumPy’s polynomial library also has tools for integration. The hermite_e module allows for direct calculation of the Hermite E polynomials, which can then be integrated using the polynomials’ integ() method.

Here’s an example:

import numpy as np

n = 3
coefficients = hermite_e_coeffs(n)
hermite_poly = np.polynomial.hermite_e.HermiteE(coefficients)
integrated_poly = hermite_poly.integ()

print(integrated_poly)

Output:

poly1d([ 8.,  0., -8.,  0.])

In this method, a Hermite E polynomial is expressed using NumPy’s polynomial classes, then integrated using integ(). The output is a Poly1d object representing the integrated polynomial.

Method 4: Recursive Hermite Polynomial Integration

For a more educational approach, Hermite polynomials can be integrated by implementing the recursive definition in Python and manually carrying out the integration process.

Here’s an example:

def hermite_recur(n, x):
    if n == 0:
        return 1
    elif n == 1:
        return x
    else:
        return x * hermite_recur(n-1, x) - (n-1) * hermite_recur(n-2, x)

def integrate_hermite_recur(n, a, b):
    integrated, _ = quad(hermite_recur, a, b, args=(n,))
    return integrated

print(integrate_hermite_recur(3, 0, 1))

Output:

-0.12500000000000003

This snippet defines the Hermite polynomials using their recursive relation and then calculates the integral over an interval using quad(). It’s a hybrid approach combining the clarity of mathematical definitions with numerical methods for integration.

Bonus One-Liner Method 5: Using Lambda Function and SciPy

Integrate a Hermite E polynomial in a single line of code, combining Python’s lambda functions with SciPy’s quad() integration method. This approach is useful for quick calculations and short scripts.

Here’s an example:

print(quad(lambda x: np.polynomial.hermite_e.hermeval(x, [0, 0, 0, 1]), 0, 1)[0])

Output:

-0.12500000000000003

This one-liner uses a lambda function to define the Hermite E polynomial and integrates it between 0 and 1, showcasing Python’s power to perform complex operations succinctly.

Summary/Discussion

Method 1:

Method 2:

Method 3:

Method 4:

One-Liner Method 5: