Double integral (dblquad) in SciPy - Step-by-Step Execution

Concept Flow - Double integral (dblquad)

Define function f(y,x)

↓

Set integration limits for y

↓

Set integration limits for x

↓

Call dblquad(f, x_lower, x_upper, y_lower(x), y_upper(x))

↓

Compute inner integral over y

↓

Compute outer integral over x

↓

Return total integral and error estimate

The process defines the function and integration limits, then computes the inner integral over y for each x, followed by the outer integral over x, returning the total integral value.

Execution Sample

SciPy

from scipy.integrate import dblquad

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

This code calculates the double integral of f(y,x) = x*y over x from 0 to 2 and y from 0 to 3.

Execution Table

Step	Action	x value	Inner integral over y	Partial result	Notes
1	Start dblquad	-	-	-	Begin integration over x from 0 to 2
2	Evaluate inner integral at x=0	0	Integral of 0*y dy from 0 to 3 = 0	0	f(y,0) = 0 for all y
3	Evaluate inner integral at x=1	1	Integral of 1*y dy from 0 to 3 = 4.5	Partial outer integral accumulates	Integral y dy = y^2/2 from 0 to 3 = 4.5
4	Evaluate inner integral at x=2	2	Integral of 2*y dy from 0 to 3 = 9	Partial outer integral accumulates	Double the previous inner integral value
5	Compute outer integral over x	-	-	Total integral = 9	Integral of inner results over x from 0 to 2
6	Return result and error	-	-	9.0	Integration complete

💡 Integration completes after evaluating inner integrals at sample points and summing over x range

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
x	-	0	1	2	-
inner_integral	-	0	4.5	9	-
result	-	-	-	-	9.0

Key Moments - 3 Insights

Why does the function f take arguments in the order (y, x) instead of (x, y)?

In dblquad, the function must be defined as f(y, x) because the integration is done first over y (inner integral), then over x (outer integral). This matches the calling convention shown in the execution_table steps.

How are the limits for y defined as functions of x?

The limits for y are given as functions of x (here constant 0 and 3). This allows flexible integration regions. The execution_table shows these limits used at each x step.

Why do we see partial inner integrals before the final result?

dblquad computes the inner integral over y for each x, then sums these results over x. The execution_table rows 2-4 show these partial inner integrals accumulating to the final total.

Visual Quiz - 3 Questions

Look at the execution_table, what is the inner integral value at x=1?

A 0

B 9

C 4.5

D 3

💡 Hint

Check row 3 in the execution_table under 'Inner integral over y'

At which step does the outer integral complete?

A Step 4

B Step 5

C Step 6

D Step 3

💡 Hint

Look for the step where the total integral is computed over x in the execution_table

If the upper limit for y changed from 3 to 4, how would the inner integral at x=1 change?

A It would become 8

B It would stay 4.5

C It would become 6

D It would become 9

💡 Hint

Recall inner integral at x=1 is integral of y dy from 0 to upper limit; use formula y^2/2

Concept Snapshot

dblquad syntax: dblquad(f, x_lower, x_upper, y_lower(x), y_upper(x))
Function f(y,x) integrates first over y, then x.
Limits for y can depend on x.
Returns integral value and error estimate.
Used for calculating area/volume under surfaces.

Full Transcript

This visual execution traces how the scipy dblquad function calculates a double integral. We start by defining the function f(y,x) and the integration limits for x and y. The integration proceeds by first computing the inner integral over y for fixed x values, then summing these results over x. The execution table shows step-by-step inner integral values at sample x points and the accumulation to the final integral result. Key points include the argument order of f(y,x), the use of limits for y as functions of x, and the two-stage integration process. The visual quiz tests understanding of these steps and how changing limits affects results.

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