Solving ODEs (solve_ivp) in SciPy - Mini Project: Build & Apply

Solving ODEs with solve_ivp

📖 Scenario: Imagine you are studying how a simple population grows over time. The population changes according to a rule that depends on its current size. This is a common problem in biology and ecology.

🎯 Goal: You will write a program to solve a simple ordinary differential equation (ODE) that models population growth using solve_ivp from the scipy library. You will define the growth rule, set the time range, solve the ODE, and then display the population values over time.

📋 What You'll Learn

Use the solve_ivp function from scipy.integrate to solve the ODE

Define the ODE function with the correct signature

Set the initial population value and time span

Extract and print the solution values

💡 Why This Matters

🌍 Real World

Solving ODEs is essential in fields like biology, physics, and engineering to model how things change over time, such as populations, chemical reactions, or mechanical systems.

💼 Career

Data scientists and analysts often need to model dynamic systems and predict future behavior, making ODE solving a useful skill in simulation and forecasting tasks.

1

Define the population growth function

Import solve_ivp from scipy.integrate and define a function called population_growth that takes t and y as inputs and returns 0.1 * y. This models a growth rate of 10%.

SciPy

# Import solve_ivp and define the population_growth function
# Your code here

Hint

Remember, the function for solve_ivp must take time t and state y as inputs and return the rate of change.

2

Set the initial population and time span

Create a variable called y0 and set it to [100] to represent the initial population. Create a variable called t_span and set it to the tuple (0, 50) to represent the time from 0 to 50.

SciPy

from scipy.integrate import solve_ivp

def population_growth(t, y):
    return 0.1 * y

# Set initial population y0 and time span t_span
# Your code here

Hint

The initial population should be a list or array with one value, and the time span is a tuple with start and end times.

3

Solve the ODE using solve_ivp

Use solve_ivp with the function population_growth, the time span t_span, and the initial value y0. Save the result in a variable called solution.

SciPy

from scipy.integrate import solve_ivp

def population_growth(t, y):
    return 0.1 * y


y0 = [100]
t_span = (0, 50)

# Solve the ODE and save the result in solution
# Your code here

Hint

Call solve_ivp with the function, time span, and initial values in that order.

4

Print the population values over time

Print the array solution.t which contains the time points, and then print solution.y[0] which contains the population values at those times.

SciPy

from scipy.integrate import solve_ivp

def population_growth(t, y):
    return 0.1 * y


y0 = [100]
t_span = (0, 50)

solution = solve_ivp(population_growth, t_span, y0)

# Print the time points and population values
# Your code here

Hint

Use print(solution.t) and print(solution.y[0]) to show the time points and population values.

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