Double integral (dblquad) in SciPy

Introduction

We use double integrals to find the total value of something spread over a flat area, like the total heat on a metal plate or the total rainfall over a region.

Calculating the total mass of a thin sheet with varying density.

Finding the total amount of rainfall over a rectangular area.

Determining the total heat energy distributed over a surface.

Computing the area under a surface defined by a function of two variables.

Syntax

SciPy

scipy.integrate.dblquad(func, a, b, gfun, hfun)

# func: function to integrate, takes two variables (y, x)
# a, b: limits for x (outer integral)
# gfun, hfun: functions giving lower and upper limits for y (inner integral), each takes x

The function func must have the order of variables as func(y, x), not func(x, y).

The limits a and b are for the outer integral (x), and gfun and hfun define the inner integral limits (y) depending on x.

Examples

This calculates the integral of x + y over the square from 0 to 1 in both x and y.

SciPy

from scipy.integrate import dblquad

# Integrate f(x,y) = x + y over x=0..1 and y=0..1
result, error = dblquad(lambda y, x: x + y, 0, 1, lambda x: 0, lambda x: 1)

This integrates over a triangular region where y goes from 0 to x.

SciPy

from scipy.integrate import dblquad

# Integrate f(x,y) = x*y over x=0..2 and y=0..x
result, error = dblquad(lambda y, x: x * y, 0, 2, lambda x: 0, lambda x: x)

Sample Program

This program calculates the double integral of the function x² + y² over the square area where both x and y go from 0 to 1.

SciPy

from scipy.integrate import dblquad

# Define the function to integrate: f(x,y) = x**2 + y**2
func = lambda y, x: x**2 + y**2

# Set the limits for x: 0 to 1
x_lower = 0
x_upper = 1

# Set the limits for y: 0 to 1
y_lower = lambda x: 0
y_upper = lambda x: 1

# Perform the double integral
result, error = dblquad(func, x_lower, x_upper, y_lower, y_upper)

print(f"Double integral result: {result}")
print(f"Estimated error: {error}")

Important Notes

The order of variables in the function is important: it must be func(y, x), not func(x, y).

The limits for the inner integral (y) can depend on the outer variable (x), allowing integration over irregular shapes.

The function returns two values: the integral result and an estimate of the error.

Summary

Double integrals calculate totals over 2D areas.

Use scipy.integrate.dblquad with the function, outer limits, and inner limits.

Remember the function takes variables in the order (y, x), and inner limits can depend on x.

Practice

1. What does the scipy.integrate.dblquad function compute in data science?

easy

A. The derivative of a function at a point

B. The maximum value in a dataset

C. The sum of elements in a list

D. The double integral of a function over a 2D area

Solution

1. Step 1: Understand the purpose of dblquad

   The dblquad function calculates the double integral, which means it sums values of a function over a two-dimensional area.

2. Step 2: Compare with other options

   Derivatives, sums, and maximum values are different operations. Only The double integral of a function over a 2D area correctly describes double integration.

3. Final Answer:

   The double integral of a function over a 2D area -> Option D

4. Quick Check:

   dblquad = double integral [OK]

Hint: dblquad integrates over 2D areas, not single values [OK]

Common Mistakes:

• Confusing integration with differentiation
• Thinking dblquad sums list elements
• Mixing up max value with integral

2. Which of the following is the correct syntax to call dblquad for integrating f(y, x) = x + y over x from 0 to 1 and y from 0 to x?

easy

A. dblquad(lambda y, x: x + y, 0, 1, lambda x: 0, lambda x: x)

B. dblquad(lambda x, y: x + y, 0, 1, lambda y: 0, lambda y: y)

C. dblquad(lambda y, x: x + y, 0, 1, 0, 1)

D. dblquad(lambda x, y: x + y, 0, 1, 0, 1)

Solution

1. Step 1: Check function argument order

   The function must be f(y, x), so lambda should be lambda y, x: x + y.

2. Step 2: Verify integration limits

   Outer limits are for x: 0 to 1. Inner limits for y depend on x: from 0 to x, so lambda x: 0 and lambda x: x.

3. Final Answer:

   dblquad(lambda y, x: x + y, 0, 1, lambda x: 0, lambda x: x) -> Option A

4. Quick Check:

   Function args (y,x) and limits correct [OK]

Hint: Remember function args order: y first, then x [OK]

Common Mistakes:

• Swapping x and y in lambda
• Using fixed inner limits instead of functions
• Passing inner limits as numbers instead of lambdas

3. What is the output of this code?

from scipy.integrate import dblquad
result, error = dblquad(lambda y, x: x * y, 0, 2, lambda x: 0, lambda x: 3)
print(round(result, 2))

medium

A. 18.00

B. 12.00

C. 9.00

D. 6.00

Solution

1. Step 1: Understand the integral setup

   Integrate f(y,x) = x*y over x from 0 to 2, and y from 0 to 3.

2. Step 2: Calculate the double integral manually

   Inner integral over y: ∫0^3 x*y dy = x * (3^2/2) = 4.5x.
   Outer integral over x: ∫0^2 4.5x dx = 4.5 * (2^2/2) = 4.5 * 2 = 9.

3. Final Answer:

   9.00 -> Option C

4. Quick Check:

   Integral value = 9.00 [OK]

Hint: Integrate inner variable first, then outer [OK]

Common Mistakes:

• Mixing order of integration
• Forgetting to multiply by x in inner integral
• Rounding errors

4. Identify the error in this code snippet:

from scipy.integrate import dblquad
result = dblquad(lambda y, x: x + y, 0, 1, 0, 1)
print(result[0])

medium

A. Function arguments should be (x, y), not (y, x)

B. Inner limits must be functions, not numbers

C. Outer limits must be functions, not numbers

D. dblquad returns only one value, not a tuple

Solution

1. Step 1: Check inner limits format

   Inner limits must be functions of the outer variable (x), but here they are fixed numbers (0, 1).

2. Step 2: Confirm function argument order and return

   Function arguments (y, x) are correct. dblquad returns a tuple (result, error), so accessing result[0] is valid.

3. Final Answer:

   Inner limits must be functions, not numbers -> Option B

4. Quick Check:

   Inner limits need lambdas [OK]

Hint: Inner limits must be functions of outer variable [OK]

Common Mistakes:

• Passing numbers instead of functions for inner limits
• Swapping argument order in lambda
• Ignoring dblquad's tuple return

5. You want to compute the double integral of f(y, x) = x2 * y over x from 0 to 1 and y from 0 to x. Which code correctly computes this using dblquad?

hard

A. dblquad(lambda y, x: x**2 * y, 0, 1, lambda x: 0, lambda x: x)

B. dblquad(lambda x, y: x**2 * y, 0, 1, lambda y: 0, lambda y: 1)

C. dblquad(lambda y, x: x**2 * y, 0, 1, 0, 1)

D. dblquad(lambda y, x: x**2 * y, 0, 1, lambda y: 0, lambda y: 1)

Solution

1. Step 1: Confirm function argument order

   Function must be f(y, x), so lambda is lambda y, x: x**2 * y.

2. Step 2: Set integration limits correctly

   Outer limits for x: 0 to 1. Inner limits for y: 0 to x, so lambda x: 0 and lambda x: x.

3. Step 3: Check other options

   A uses numbers instead of functions for inner limits. B uses wrong argument order in the lambda (x, y) and constant inner limits. D uses lambda y: instead of lambda x:, resulting in constant inner limits instead of 0 to x.

4. Final Answer:

   dblquad(lambda y, x: x**2 * y, 0, 1, lambda x: 0, lambda x: x) -> Option A

5. Quick Check:

   Correct args and limits functions [OK]

Hint: Always use lambdas for inner limits, even if constant [OK]

Common Mistakes:

• Swapping x and y in lambda
• Using numbers instead of lambdas for inner limits
• Using wrong variable names in inner limit lambdas