Double integral (dblquad) in SciPy - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the function for double integration from scipy.

SciPy

from scipy.integrate import [1]

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

Drag options to blanks, or click blank then click option'

Adblquad

Bquad

Ctrapz

Dsimps

Attempts:

3 left

💡 Hint

Common Mistakes

Importing 'quad' instead of 'dblquad'.

Using 'trapz' or 'simps' which are for numerical integration but not double integrals.

The dblquad function is used for double integrals in scipy.integrate.

2fill in blank

medium

Complete the code to set the limits of integration for y as functions of x.

SciPy

from scipy.integrate import dblquad

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

Drag options to blanks, or click blank then click option'

Alambda x: 0

Blambda y: 3

Clambda x: 2

Dlambda y: 0

Attempts:

3 left

💡 Hint

Common Mistakes

Using lambda with y instead of x for limits.

Using a constant instead of a function for limits.

The lower limit for y must be a function of x, so lambda x: 0 is correct.

3fill in blank

hard

Fix the error in the order of variables in the integrand function for dblquad.

SciPy

from scipy.integrate import dblquad

result, error = dblquad(lambda [1], 0, 1, lambda x: 0, lambda x: 1)
print(result)

Drag options to blanks, or click blank then click option'

Ax, y: y*x

By, x: x*y

Cx, y: x*y

Dy, x: y*x

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the order of variables in the lambda function.

Using y first instead of x.

The integrand function for dblquad must have the order lambda x, y: ....

4fill in blank

hard

Fill both blanks to correctly compute the double integral of f(x,y) = x^2 + y^2 over x in [0,1] and y in [0,2].

SciPy

from scipy.integrate import dblquad

result, error = dblquad(lambda [1]: x**2 + y**2, 0, 2, [2], lambda y: 1)
print(result)

Drag options to blanks, or click blank then click option'

Ax, y

By, x

Clambda y: 0

Dlambda x: 0

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping x and y in the lambda function.

Using a constant instead of a function for limits.

The integrand must be lambda x, y and the lower limit for x is lambda y: 0.

5fill in blank

hard

Fill all three blanks to compute the double integral of f(x,y) = x*y over x in [0, y] and y in [0, 1].

SciPy

from scipy.integrate import dblquad

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

Drag options to blanks, or click blank then click option'

Ax, y

Blambda y: 0

Clambda y: y

Dlambda x: 1

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the order of variables in the lambda function.

Using incorrect limits for the inner integral.

The integrand is lambda x, y, the lower limit for x is lambda y: 0, and the upper limit for x is lambda y: y.

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