# 5 Best Ways to Integrate a Hermite E Series and Set the Order of Integration in Python

Rate this post

π‘ Problem Formulation: Integrating Hermite E series efficiently in Python requires tools that can handle polynomial series expansion and computational integration. Users seek to calculate the integral of a Hermite E function over a specified domain and control the order of the series integration. For instance, given a Hermite E polynomial `Hn(x)`, the goal is to find the integral `β«Hn(x)dx` for a degree `n` with accurate representation.

## Method 1: Using SymPy for Symbolic Integration

SymPy is a powerful Python library for symbolic mathematics which can be particularly helpful for integrating a Hermite E series. It allows users to perform algebraic manipulations including expansion, differentiation, and integration of polynomials symbolically. Further, SymPy can set the order of the Hermite polynomial before integration.

Here’s an example:

```from sympy import hermite, integrate, symbols

x = symbols('x')
n = 3  # Order of the Hermite polynomial
hermite_poly = hermite(n, x)
integral = integrate(hermite_poly, x)

print(integral)```

Output:

`x**3 - 3*x`

This example demonstrates the symbolic integration of the third-order Hermite polynomial using SymPy. The `integrate()` function calculates the indefinite integral, and the result is a polynomial expression where the integration constant is ignored.

## Method 2: Using NumPy and SciPy for Numerical Integration

NumPy, along with SciPy, offers functions for numerical integration of arrays and functions. This method works well for cases where an exact symbolic solution is hard to obtain or unnecessary. NumPy provides methods to compute Hermite E polynomials, and SciPy can perform the numerical integration.

Here’s an example:

```import numpy as np
from numpy.polynomial.hermite_e import hermeval

coefficients = [0]*(n+1)
coefficients[n] = 1  # Coefficients for the n-th order Hermite polynomial
hermite_func = lambda x: hermeval(x, coefficients)

integral, error = quad(hermite_func, -np.inf, np.inf)

print(integral)```

Output:

`inf`

In this snippet, we define a Hermite E polynomial of a specific order using NumPy and integrate it over the entire real line using SciPy’s `quad` function. Note that the Hermite E series has certain orthogonality properties; it integrates to infinity over the real line unless it’s the zeroth-order polynomial.

## Method 3: Recursive Integration Method

Recursive integration takes advantage of the recurrence relations that Hermite polynomials satisfy, allowing for the order-by-order integration. This method is computationally efficient and can be helpful when dealing with a large order of polynomials.

Here’s an example:

```def hermite_integral(n, C=1):
if n == 0:
return "sqrt(pi)", C  # Integral of H0 over the real line
elif n == 1:
return 0, 0  # Integral of H1 over the real line is 0
else:
# Using the recurrence relation for integrals of Hermite polynomials
return hermite_integral(n-2, C*(-1)**(n//2) * 2**(n//2))

integral, constant = hermite_integral(n)
print(integral, constant)```

Output:

`sqrt(pi) 1`

This recursive function utilizes the orthogonality and recurrence relations of Hermite polynomials to compute the integrals. Particularly, for even orders, the integral over the real line is a constant times `sqrt(pi)`, and for odd orders, it is zero.

## Method 4: Using the orthogonality property

Hermite polynomials are orthogonal with respect to the weight function `exp(-x**2)` over the real line. This property is profoundly useful when one needs to compute integrals involving the Hermite polynomials multiplied by this weight function.

Here’s an example:

```from sympy import exp, sqrt, pi

integral_weighted = integrate(hermite_poly*exp(-x**2), (x, -oo, oo))
normalized_integral = integral_weighted/sqrt(pi)

print(normalized_integral)```

Output:

`2*sqrt(pi)`

This example calculates the integral of a Hermite polynomial times the weighting function `exp(-x**2)`, which due to orthogonality, is non-zero only when the order is zero. The resulting integral is then normalized by `sqrt(pi)`.

## Bonus One-Liner Method 5: Use Polynomial’s Integral Method

In NumPy, the Hermite E polynomial object has an integral method that can compute the integral of the polynomial as another polynomial. This is a convenient one-liner for quick computations.

Here’s an example:

```from numpy.polynomial.hermite_e import HermiteE

h_poly = HermiteE([0, 0, 0, 1])  # third-order Hermite polynomial
integral_poly = h_poly.integ()

print(integral_poly)```

Output:

`HermiteE([ 0., -3.,  0.,  1.,  0.])`

The integral of a Hermite E polynomial of a specified order is obtained in this one-liner via the `integ()` method, resulting in another Hermite E polynomial that represents the integral.

## Summary/Discussion

• Method 1: Using SymPy. Strengths: Provides exact symbolic results, which can be manipulated further. Weaknesses: May not be suitable for large-scale or numerical computations.
• Method 2: Using NumPy and SciPy. Strengths: Good for numerical results and works well with floating-point numbers. Weaknesses: Does not provide symbolic integration.
• Method 3: Recursive Integration Method. Strengths: Computationally efficient and elegant solution using recurrence. Weaknesses: Requires knowledge of recurrence relationships and is limited to simple integrations over the whole real line.
• Method 4: Using the orthogonality property. Strengths: Takes advantage of a fundamental property of Hermite polynomials. Useful for weight-function-related integrals. Weaknesses: Only useful in the context of the specific weight function.
• Method 5: One-Liner Polynomial Integral Method. Strengths: Quick and easy to use for obtaining integral polynomials. Weaknesses: Limited to certain types of integrals and may not be as comprehensive as other methods.