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.

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