Double integral (dblquad) in SciPy - Mini Project: Build & Apply

Calculate Area Using Double Integral with dblquad

📖 Scenario: Imagine you want to find the area under a curved surface over a specific region. This is common in fields like physics and engineering when calculating volumes or probabilities.

🎯 Goal: You will learn how to use the dblquad function from scipy.integrate to calculate a double integral over a rectangular region.

📋 What You'll Learn

Create a function representing the surface to integrate

Define the limits of integration for both variables

Use dblquad to compute the double integral

Print the result of the integration

💡 Why This Matters

🌍 Real World

Double integrals are used in physics to find volumes under surfaces, in probability to find joint probabilities, and in engineering for stress analysis.

💼 Career

Knowing how to compute double integrals with tools like scipy is useful for data scientists and engineers working with continuous data and modeling.

1

Define the function to integrate

Create a function called f that takes two variables x and y and returns the value of x * y.

SciPy

# Define the function f(x, y) = x * y
# Your code here

Hint

Remember, the function should take two inputs and return their product.

2

Set the integration limits

Create variables x_lower and x_upper with values 0 and 2 respectively. Also create two functions y_lower and y_upper that take x as input and return 0 and 3 respectively.

SciPy

def f(x, y):
    return x * y

# Define x_lower = 0 and x_upper = 2
# Define y_lower(x) = 0 and y_upper(x) = 3
# Your code here

Hint

Use simple functions for y limits that ignore x and return constants.

3

Calculate the double integral using dblquad

Import dblquad from scipy.integrate. Then create a variable result that stores the output of dblquad called with f, x_lower, x_upper, y_lower, and y_upper.

SciPy

def f(x, y):
    return x * y

x_lower = 0
x_upper = 2
def y_lower(x):
    return 0
def y_upper(x):
    return 3

# Import dblquad and calculate the double integral
# Your code here

Hint

Remember dblquad returns two values: the integral result and an estimate of the error.

4

Print the result of the double integral

Write a print statement to display the value stored in result.

SciPy

from scipy.integrate import dblquad

def f(x, y):
    return x * y

x_lower = 0
x_upper = 2
def y_lower(x):
    return 0
def y_upper(x):
    return 3

result, error = dblquad(f, x_lower, x_upper, y_lower, y_upper)

# Print the result
# Your code here

Hint

The integral of x*y over x=0..2 and y=0..3 is 6.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