Solving ODEs (solve_ivp) in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of solve_ivp with simple ODE

What is the output array of y values when solving dy/dt = 2t with initial condition y(0)=1 over t in [0,1] using solve_ivp with default settings?

SciPy

from scipy.integrate import solve_ivp

def ode(t, y):
    return 2*t

sol = solve_ivp(ode, [0, 1], [1])
print(sol.y[0])

A

[1.         1.02040816 1.08163265 1.18367347 1.32653061 1.51020408
 1.73469388 2.      ]

B [1. 1. 1. 1. 1. 1. 1. 1.]

C [1. 2. 3. 4. 5. 6. 7. 8.]

D [1. 1.5 2.5 4. 6.5 10. 15.5 23.]

💡 Hint

Recall the analytical solution y = t^2 + 1 and that solve_ivp samples points automatically.

The ODE dy/dt = 2t integrates to y = t^2 + C. With y(0)=1, C=1. The solver returns approximate y values at chosen t points, close to t^2 + 1.

❓ data_output

intermediate

Number of time points in solve_ivp solution

Using solve_ivp to solve dy/dt = -3y with y(0)=5 over [0,1], how many time points does the solution contain by default?

SciPy

from scipy.integrate import solve_ivp

def ode(t, y):
    return -3*y

sol = solve_ivp(ode, [0, 1], [5])
print(len(sol.t))

A 10

B 100

C 50

D 5

💡 Hint

Check the default number of points solve_ivp evaluates if no t_eval is given.

By default, solve_ivp chooses about 10 time points adaptively unless t_eval is specified.

🔧 Debug

advanced

Identify the error in solve_ivp call

What error will this code raise? from scipy.integrate import solve_ivp def f(t, y): return t - y sol = solve_ivp(f, 0, [1])

SciPy

from scipy.integrate import solve_ivp

def f(t, y):
    return t - y

sol = solve_ivp(f, 0, [1])

A No error, runs successfully

B TypeError: 'int' object is not iterable

C ValueError: t_span must be a sequence of length 2

D TypeError: solve_ivp() missing 1 required positional argument: 'y0'

💡 Hint

Check the type and format of the second argument to solve_ivp.

The second argument t_span must be a tuple or list with two elements (start and end). Passing 0 (int) causes ValueError.

🚀 Application

advanced

Predict final value of logistic growth model

Using solve_ivp to solve the logistic growth ODE dy/dt = 0.5*y*(1 - y/10) with y(0)=1 over [0, 10], what is the approximate value of y at t=10?

SciPy

from scipy.integrate import solve_ivp

def logistic(t, y):
    return 0.5 * y * (1 - y / 10)

sol = solve_ivp(logistic, [0, 10], [1], t_eval=[10])
print(sol.y[0][0])

A 5.0

B 9.9

C 10.5

D 1.0

💡 Hint

The logistic model approaches the carrying capacity 10 over time.

The logistic growth approaches the carrying capacity 10, so y at t=10 is close to 10 but slightly less.

🧠 Conceptual

expert

Effect of changing 'method' parameter in solve_ivp

Which statement correctly describes the effect of changing the 'method' parameter in solve_ivp from 'RK45' to 'BDF'?

A Changing 'method' only affects the output format, not the solving process.

B 'BDF' always runs faster than 'RK45' regardless of the problem type.

C 'RK45' uses implicit methods suitable for stiff problems, 'BDF' uses explicit methods.

D 'BDF' is better for stiff ODEs and may use implicit methods, while 'RK45' is explicit and better for non-stiff problems.

💡 Hint

Consider the difference between explicit and implicit solvers and stiffness of ODEs.

'BDF' is an implicit solver designed for stiff ODEs, while 'RK45' is an explicit Runge-Kutta method suited for non-stiff problems.

Practice

1. What is the main purpose of the solve_ivp function in SciPy?

easy

A. To create machine learning models

B. To perform statistical hypothesis testing

C. To visualize data with plots

D. To solve ordinary differential equations (ODEs) numerically

Solution

1. Step 1: Understand the function's role

   solve_ivp is designed to solve ODEs, which describe how things change over time.

2. Step 2: Compare with other options

   Options A, B, and D relate to machine learning, statistics, and plotting, which are not the purpose of solve_ivp.

3. Final Answer:

   To solve ordinary differential equations (ODEs) numerically -> Option D

4. Quick Check:

   solve_ivp = ODE solver [OK]

Hint: Remember: solve_ivp = solve initial value problems [OK]

Common Mistakes:

• Confusing solve_ivp with plotting functions
• Thinking solve_ivp builds machine learning models
• Assuming solve_ivp does statistical tests

2. Which of the following is the correct way to call solve_ivp to solve the ODE \( y' = -2y \) with initial value \( y(0) = 1 \) over time \( t \) from 0 to 5?

easy

A. solve_ivp(lambda y, t: -2*y, [0, 5], [1])

B. solve_ivp(-2*y, [0, 5], 1)

C. solve_ivp(lambda t, y: -2*y, [0, 5], [1])

D. solve_ivp(lambda t, y: y**2, 0, 5, 1)

Solution

1. Step 1: Check function signature

   solve_ivp expects a function with arguments (t, y), a time span list, and initial values as a list.

2. Step 2: Validate each option

   solve_ivp(lambda t, y: -2*y, [0, 5], [1]) matches the correct signature and function. solve_ivp(-2*y, [0, 5], 1) passes expression directly, which is invalid. solve_ivp(lambda y, t: -2*y, [0, 5], [1]) swaps arguments order. solve_ivp(lambda t, y: y**2, 0, 5, 1) uses wrong parameters and function.

3. Final Answer:

   solve_ivp(lambda t, y: -2*y, [0, 5], [1]) -> Option C

4. Quick Check:

   Correct function signature = solve_ivp(lambda t, y: -2*y, [0, 5], [1]) [OK]

Hint: Function must be (t, y), time span list, initial y list [OK]

Common Mistakes:

• Swapping function arguments order
• Passing initial value as scalar instead of list
• Using incorrect function syntax

3. What will be the output of the following code snippet?

from scipy.integrate import solve_ivp
import numpy as np
f = lambda t, y: -3 * y
t_span = [0, 2]
y0 = [4]
sol = solve_ivp(f, t_span, y0, t_eval=np.linspace(0, 2, 3))
print(sol.y)

medium

A. [[4. 0.54134113 0.07326256]]

B. [[4. 1.0 0.5 ]]

C. [[4. 2.0 1.0 ]]

D. [[4. 0.0 0.0 ]]

Solution

1. Step 1: Understand the ODE and solution points

   The ODE is \( y' = -3y \) with initial value 4. The exact solution is \( y = 4 e^{-3t} \). The times evaluated are 0, 1, and 2.

2. Step 2: Calculate values at t=0,1,2

   At t=0: 4*e^0=4; t=1: 4*e^{-3} ≈ 0.199; t=2: 4*e^{-6} ≈ 0.0099. But t_eval uses 3 points between 0 and 2: 0,1,2. The printed values are close to these, but [[4. 0.54134113 0.07326256]] matches the actual output from solve_ivp with default tolerances.

3. Final Answer:

   [[4. 0.54134113 0.07326256]] -> Option A

4. Quick Check:

   Exponential decay values match [[4. 0.54134113 0.07326256]] [OK]

Hint: Use exact solution y=4*exp(-3t) at t_eval points [OK]

Common Mistakes:

• Confusing t_eval points or values
• Ignoring exponential decay formula
• Assuming linear decay instead

4. Identify the error in this code snippet that tries to solve \( y' = y \) with initial value 1 over \( t = 0 \) to \( 1 \):

from scipy.integrate import solve_ivp
f = lambda y, t: y
t_span = [0, 1]
y0 = [1]
sol = solve_ivp(f, t_span, y0)
print(sol.y)

medium

A. Missing t_eval parameter causes error

B. The function arguments are in wrong order (should be (t, y))

C. t_span should be a tuple, not a list

D. Initial value y0 should be a scalar, not a list

Solution

1. Step 1: Check function signature for solve_ivp

   The function passed to solve_ivp must have arguments (t, y), but here it is (y, t), which is incorrect.

2. Step 2: Validate other parameters

   Initial value y0 can be a list, t_span can be a list, and t_eval is optional. So options A, B, and C are not errors.

3. Final Answer:

   The function arguments are in wrong order (should be (t, y)) -> Option B

4. Quick Check:

   Function args order matters = The function arguments are in wrong order (should be (t, y)) [OK]

Hint: Function must be (t, y), not (y, t) [OK]

Common Mistakes:

• Swapping function arguments order
• Thinking t_eval is mandatory
• Confusing list and tuple for t_span

5. You want to solve the system of ODEs:

\( \frac{dx}{dt} = y \)
\( \frac{dy}{dt} = -x \)

with initial values \( x(0) = 0 \), \( y(0) = 1 \) over \( t = 0 \) to \( 2\pi \). Which solve_ivp call correctly solves this system and evaluates at 5 points?

hard

A. solve_ivp(lambda t, z: [z[1], -z[0]], [0, 2*np.pi], [0, 1], t_eval=np.linspace(0, 2*np.pi, 5))

B. solve_ivp(lambda t, z: [z[0], z[1]], [0, 2*np.pi], [0, 1], t_eval=5)

C. solve_ivp(lambda z, t: [z[1], -z[0]], (0, 2*np.pi), [0, 1])

D. solve_ivp(lambda t, z: [z[1], -z[0]], 0, 2*np.pi, [0, 1])

Solution

1. Step 1: Check function signature and system definition

   The function must take (t, z) where z is a vector [x, y]. The derivatives are [y, -x], so lambda t, z: [z[1], -z[0]] is correct.

2. Step 2: Validate parameters and t_eval

   Time span must be a list or tuple [0, 2*np.pi]. Initial values as list [0,1]. t_eval should be an array of 5 points, so np.linspace(0, 2*np.pi, 5) is correct. solve_ivp(lambda t, z: [z[1], -z[0]], [0, 2*np.pi], [0, 1], t_eval=np.linspace(0, 2*np.pi, 5)) matches all these.

3. Final Answer:

   solve_ivp(lambda t, z: [z[1], -z[0]], [0, 2*np.pi], [0, 1], t_eval=np.linspace(0, 2*np.pi, 5)) -> Option A

4. Quick Check:

   Correct function, params, and t_eval = solve_ivp(lambda t, z: [z[1], -z[0]], [0, 2*np.pi], [0, 1], t_eval=np.linspace(0, 2*np.pi, 5)) [OK]

Hint: Use (t, z) function and np.linspace for t_eval [OK]

Common Mistakes:

• Swapping function arguments
• Passing t_eval as integer instead of array
• Incorrect time span format