Multiple Integration with SciPy

Multiple integration in SciPy allows you to compute integrals of functions with more than one variable, such as double, triple, or n-dimensional integrals. The scipy.integrate module offers robust tools for efficiently handling these complex integrations, finding applications in physics, engineering, probability distributions, and more.

What is Multiple Integration?

Multiple integration involves calculating the integral of a function over a specified region in multi-dimensional space. For a function $f(x_1, x_2, \ldots, x_n)$, an n-dimensional integral over a region $D$ is defined as:

$$ \int \cdots \int_D f(x_1, x_2, \ldots, x_n) dx_1 dx_2 \ldots dx_n $$

Where:

• $D$ represents the region of integration.
• $f$ is the function being integrated.

SciPy provides several functions tailored for multiple integration, with nquad being the most general for n-dimensional integrals.

Key Integration Functions in SciPy

• quad: For single-variable integration.
• dblquad: For double integration.
• tplquad: For triple integration.
• nquad: For general n-dimensional integration.

While dblquad and tplquad are specialized, nquad is a versatile function capable of handling integrations of any dimension and offers greater flexibility.

The nquad Function

The scipy.integrate.nquad function is the primary tool for performing general n-dimensional integration.

Syntax

scipy.integrate.nquad(func, ranges, args=None, opts=None, full_output=False)

Parameters

• func: The function to be integrated. This function should accept the integration variables as separate arguments (e.g., func(x, y, z) for a triple integral).
• ranges: A list of tuples, where each tuple specifies the lower and upper bounds for each integration variable. The order of the tuples must correspond to the order of the variables in func.
  • For a fixed upper/lower bound: (lower_bound, upper_bound)
  • For a variable upper/lower bound (dependent on previous variables): (lower_bound, upper_bound_function)
• args (optional): A tuple of extra arguments to be passed to func.
• opts (optional): A dictionary of options to control the integration process, such as error tolerance (epsabs, epsrel) or the integration method.
• full_output (optional): If True, the function returns a dictionary containing additional integration metadata, including the estimated error, convergence information, and the number of function evaluations.

Return Value

By default, nquad returns a tuple:

• result: The computed value of the integral.
• error: An estimate of the absolute error in the result.

If full_output is True, it returns a tuple:

• result: The computed value of the integral.
• error: An estimate of the absolute error.
• inform: An integer indicating convergence status.
• message: A string describing the convergence status.
• detailed_results: A dictionary containing more detailed integration metadata.

Examples

Example 1: Double Integration using nquad

Let's calculate the double integral of $f(x, y) = \sin(x) + \cos(y)$ over the region $0 \le x \le \pi$ and $0 \le y \le \frac{\pi}{2}$.

import numpy as np
from scipy.integrate import nquad

# Define the integrand
def integrand(x, y):
    return np.sin(x) + np.cos(y)

# Define the integration ranges for x and y
# ranges = [[lower_bound_x, upper_bound_x], [lower_bound_y, upper_bound_y]]
ranges = [[0, np.pi], [0, np.pi / 2]]

# Perform the double integration
result, error = nquad(integrand, ranges)

print(f"Double Integral Result: {result}")
print(f"Error Estimate: {error}")

Output:

Double Integral Result: 6.283185307179586
Error Estimate: 6.975736996017264e-14

Example 2: Triple Integration using nquad

Let's calculate the triple integral of $f(x, y, z) = x^2 + y^2 + z^2$ over the unit cube ($0 \le x \le 1$, $0 \le y \le 1$, $0 \le z \le 1$).

from scipy.integrate import nquad

# Define the integrand
def func(x, y, z):
    return x**2 + y**2 + z**2

# Define the integration ranges for x, y, and z
# ranges = [[lower_x, upper_x], [lower_y, upper_y], [lower_z, upper_z]]
ranges = [[0, 1], [0, 1], [0, 1]]

# Perform the triple integration
result, error = nquad(func, ranges)

print(f"Result of the triple integration: {result}")
print(f"Estimated error: {error}")

Output:

Result of the triple integration: 1.0
Estimated error: 2.5808878251226036e-14

Example 3: Integration with Variable Limits

nquad can also handle integration limits that depend on previous variables. For instance, integrating $f(x, y) = x$ over the region $0 \le x \le 1$ and $0 \le y \le x$.

from scipy.integrate import nquad

def integrand_variable_limits(x, y):
    return x

# The upper limit of y depends on x
# ranges = [[lower_x, upper_x], [lower_y(x), upper_y(x)]]
ranges_variable = [[0, 1], lambda x: 0, lambda x: x]

result_variable, error_variable = nquad(integrand_variable_limits, ranges_variable)

print(f"Integral with variable limits: {result_variable}")
print(f"Estimated error: {error_variable}")

Output:

Integral with variable limits: 0.16666666666666666
Estimated error: 1.861004456205413e-15

Key Features of nquad

• N-Dimensional Support: Seamlessly handles integrals of any number of dimensions.
• Flexible Limits: Supports both constant and variable integration limits, where bounds can be functions of preceding variables.
• Extensible: Can incorporate extra arguments into the integrand function.
• Customizable Precision: Allows fine-grained control over accuracy through optional parameters like epsabs and epsrel.
• Infinite Limits: Can handle infinite integration bounds using np.inf and -np.inf.
• Robustness: Suitable for computationally intensive high-dimensional problems.

Applications of Multiple Integration

Multiple integrals are fundamental in various scientific and engineering disciplines:

• Physics Simulations: Calculating quantities like potential energy, mass distribution, center of mass, and moments of inertia.
• Probability and Statistics: Determining probabilities from joint probability density functions, calculating expected values, and finding volumes under density surfaces.
• Computational Geometry: Computing volumes, surface areas, and centroids of complex shapes.
• Engineering Computations: Analyzing heat flow, fluid dynamics, stress, strain, and material properties.

Conclusion

SciPy's nquad function is a powerful and flexible tool for evaluating multi-variable integrals in Python. Its ability to handle arbitrary dimensions, complex integration bounds, and customizable precision makes it an invaluable asset for solving a wide range of mathematical and scientific problems.