Double integral (dblquad) in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple double integral using dblquad

What is the output of this code that calculates the double integral of f(x, y) = x + y over the square 0 ≤ x ≤ 1 and 0 ≤ y ≤ 1?

SciPy

from scipy.integrate import dblquad

result, error = dblquad(lambda y, x: x + y, 0, 1, lambda x: 0, lambda x: 1)
print(round(result, 3))

A 1.0

B 0.5

C 2.0

D 1.5

💡 Hint

Remember the order of variables in the lambda function for dblquad is (y, x).

The integral of f(x, y) = x + y over the unit square is calculated as:

∫₀¹1 ∫₀¹1 (x + y) dy dx = ∫₀¹1 [x*y + y²/2]₀¹1 dx = ∫₀¹1 (x*1 + 1/2) dx = ∫₀¹1 (x + 0.5) dx = [x²/2 + 0.5x]₀¹1 = 0.5 + 0.5 = 1.0

The code uses the correct order lambda y, x: x + y for dblquad (inner y, outer x), so the result is 1.0.

❓ data_output

intermediate

Number of points used in dblquad integration

How many points does scipy.integrate.dblquad typically use internally to compute the double integral of f(x, y) = x*y over the region 0 ≤ x ≤ 2 and 0 ≤ y ≤ 3?

SciPy

from scipy.integrate import dblquad

result, error = dblquad(lambda y, x: x*y, 0, 2, lambda x: 0, lambda x: 3)
print(result)

A The function does not expose the number of points used directly

B Exactly 50 points

C Exactly 100 points

D Exactly 200 points

💡 Hint

Check the scipy documentation for dblquad about the number of evaluation points.

scipy.integrate.dblquad uses adaptive quadrature methods internally and does not provide a direct count of points used to the user.

🧠 Conceptual

advanced

Understanding the order of integration in dblquad

In scipy.integrate.dblquad, the function to integrate is defined as f(y, x). Why is the order of variables reversed compared to the usual mathematical notation f(x, y)?

A Because Python functions always take y before x by convention

B Because dblquad integrates first over y (inner integral) and then over x (outer integral), so y must be the first argument

C Because the library was designed incorrectly

D Because x and y are swapped internally to optimize performance

💡 Hint

Think about the order of integration in nested integrals.

The dblquad function integrates first over the inner variable y, then over the outer variable x. So the function must accept y as the first argument and x as the second to match this order.

🔧 Debug

advanced

Identify the error in this dblquad usage

What error will this code raise when trying to compute the double integral of f(x, y) = x*y over 0 ≤ x ≤ 1 and 0 ≤ y ≤ 1? from scipy.integrate import dblquad result, error = dblquad(lambda x, y: x*y, 0, 1, lambda x: 0, lambda x: 1) print(result)

SciPy

from scipy.integrate import dblquad

result, error = dblquad(lambda x, y: x*y, 0, 1, lambda x: 0, lambda x: 1)
print(result)

A TypeError because the function arguments are in the wrong order

B SyntaxError due to missing colon

C ValueError because integration limits are invalid

D No error, prints 0.25

💡 Hint

Check the order of arguments in the lambda function compared to dblquad's expected order.

No error is raised because although the arguments are named x, y, dblquad calls func(y_val, x_val), so it computes y_val * x_val, which equals x * y. The code correctly computes the integral (1/4 = 0.25).

🚀 Application

expert

Calculate the volume under a curved surface using dblquad

Using scipy.integrate.dblquad, what is the approximate value of the double integral of f(x, y) = sin(x) * cos(y) over the rectangle 0 ≤ x ≤ π and 0 ≤ y ≤ π/2?

SciPy

from scipy.integrate import dblquad
import math

result, error = dblquad(lambda y, x: math.sin(x) * math.cos(y), 0, math.pi, lambda x: 0, lambda x: math.pi/2)
print(round(result, 3))

A 0.0

B 1.0

C 2.0

D 0.5

💡 Hint

Recall the integrals of sine and cosine over these intervals.

The integral separates as ∫₀^π sin(x) dx * ∫₀^{π/2} cos(y) dy = 2 * 1 = 2. But since dblquad integrates y first, the code integrates cos(y) from 0 to π/2 (which is 1), then sin(x) from 0 to π (which is 2). The product is 2.

However, the code's order of integration is y then x, so the result is 2.0.