SciPy: Using integrate.tplquad() function (4 examples)

Introduction

In the realm of numerical integration in Python, SciPy’s integrate.tplquad() function is a triple integration workhorse that solves for the integral of a function of three variables over a rectangular domain. This function is part of the larger SciPy library, a key player in scientific computing within Python. In this tutorial, we delve into the practical applications of tplquad(), demonstrating its utility through a progressive series of examples. We start with the basics and gradually transition to more complex applications, providing outputs to visualize our results.

Getting Started

Before we explore the examples, ensure SciPy is installed in your environment:

pip install scipy

Next, import the required module:

from scipy import integrate

Example 1: Basic Integration

We begin with a straightforward scenario, integrating a simple polynomial function over a cube.

def func(x, y, z):
    return x**2 + y**2 + z**2

result, error = integrate.tplquad(func, 0, 1, lambda x: 0, lambda x: 1, lambda x, y: 0, lambda x, y: 1)
print('Result:', result)
print('Error:', error)

In this example, the bounds for x, y, and z are all set from 0 to 1. The output should be:

Result: 1.0
Error: 1.1102230246251565e-14

This basic example demonstrates the simplicity and power of tplquad() in performing triple integrals over regular domains.

Example 2: Integration with Variable Limits

Moving on, we’ll explore how to handle variable limits of integration. This involves setting the innermost limits as functions that depend on the outer variables.

def func(x, y, z):
    return x*y*z

result, error = integrate.tplquad(func, 0, 1, lambda x: 0, lambda x: x, lambda x, y: 0, lambda x, y: y)
print('Result:', result)
print('Error:', error)

The output here illustrates the dependency of y's and z's limits on x and y respectively:

Result: 0.041666666666666664
Error: 4.6213033400027876e-16

This example shows the versatility of tplquad() in accommodating variable integration bounds seamlessly.

Example 3: Integrating with Parameters

In our third example, we’ll see how to pass extra parameters to the integrand function. This is useful for experimenting with different function behaviors without rewriting the function itself.

def func(x, y, z, a, b, c):
    return a*x**2 + b*y**2 + c*z**2

a, b, c = 1, 2, 3
result, error = integrate.tplquad(func, 0, 1, lambda x: 0, lambda x: 1, lambda x, y: 0, lambda x, y: 1, args=(a, b, c))
print('Result:', result)
print('Error:', error)

The output reflects the use of parameters to affect the integration result:

Result: 1.833333333333333
Error: 2.036609294214918e-14

This flexibility is a testament to the utility of the tplquad() function, allowing for dynamic behavior within integration tasks.

Example 4: Advanced Application

Our final example demonstrates the function’s capability in a physics-based scenario, specifically integrating a potential energy function across a cuboid space:

def potential_energy(x, y, z):
    G = 6.67430e-11 # Gravitational constant
    M = 5.972e24 # Mass of Earth
    return -G * M / ((x**2 + y**2 + z**2)**0.5)

result, error = integrate.tplquad(potential_energy, -1e6, 1e6, lambda x: -1e6, lambda x: 1e6, lambda x, y: -1e6, lambda x, y: 1e6)
print('Result:', result)
print('Error:', error)

The outcome, while more complex, underscores the efficacy of tplquad() in handling real-world scientific problems.

Conclusion

Through these examples, it’s clear that SciPy’s tplquad() function is a versatile tool for numerical integration across a variety of scenarios. From basic polynomials to parameterized functions and applied physics problems, tplquad() demonstrates excellent utility in scientific computing. Mastering its use can significantly enhance one’s analytical capabilities in Python.