ODE solver methods (RK45, BDF) in SciPy - Mini Project: Build & Apply

Solving a Simple ODE with RK45 and BDF Methods

📖 Scenario: Imagine you want to understand how a simple system changes over time, like how the temperature cools down or how a population grows. We can use math equations called differential equations to describe these changes. To find out the values at different times, we use special tools called ODE solvers.

🎯 Goal: You will learn how to solve a simple ordinary differential equation (ODE) using two popular methods: RK45 and BDF. You will write code to set up the equation, choose the solver method, solve the equation, and see the results.

📋 What You'll Learn

Use the scipy.integrate.solve_ivp function to solve ODEs

Define a function for the differential equation

Set up initial conditions and time points

Solve the ODE using both RK45 and BDF methods

Print the solution values at the final time point

💡 Why This Matters

🌍 Real World

ODE solvers like RK45 and BDF are used in physics, biology, engineering, and finance to model how things change over time, such as chemical reactions, population growth, or mechanical systems.

💼 Career

Understanding how to solve ODEs with different methods is important for data scientists and engineers working on simulations, modeling, and predictive analytics.

1

Define the ODE function and initial conditions

Create a function called ode_function that takes t and y as inputs and returns -2 * y. Then create a variable called y0 and set it to [1] as the initial value. Finally, create a variable called t_span and set it to the tuple (0, 5) representing the time interval.

SciPy

# Your code here

Hint

The function should return the rate of change at time t and value y. The initial value y0 is a list with one number. The time span is a tuple with start and end times.

2

Set the solver method to RK45

Create a variable called method and set it to the string 'RK45' to choose the Runge-Kutta 45 solver method.

SciPy

def ode_function(t, y):
    return -2 * y

y0 = [1]
t_span = (0, 5)

# Your code here

Hint

Just assign the string 'RK45' to the variable method.

3

Solve the ODE using solve_ivp with the chosen method

Use solve_ivp from scipy.integrate to solve the ODE. Call it with ode_function, t_span, y0, and method=method. Save the result in a variable called solution.

SciPy

def ode_function(t, y):
    return -2 * y

y0 = [1]
t_span = (0, 5)

method = 'RK45'

# Your code here

Hint

Remember to import solve_ivp from scipy.integrate before using it.

4

Print the solution value at the final time point

Print the last value of solution.y[0] using print(). This shows the solution at the end of the time interval.

SciPy

from scipy.integrate import solve_ivp

def ode_function(t, y):
    return -2 * y

y0 = [1]
t_span = (0, 5)

method = 'RK45'

solution = solve_ivp(ode_function, t_span, y0, method=method)

# Your code here

Hint

The output should be close to 0.0067, which is the value of e^{-10}.

Practice

1. Which scipy ODE solver method is best suited for stiff problems?

easy

A. BDF

B. RK45

C. Euler

D. Midpoint

Solution

1. Step 1: Understand stiff problems

   Stiff problems require methods that handle rapid changes without instability.

2. Step 2: Match solver to problem type

   BDF (Backward Differentiation Formula) is designed for stiff problems, unlike RK45 which is for general cases.

3. Final Answer:

   BDF -> Option A

4. Quick Check:

   Stiff problems = BDF [OK]

Hint: BDF is for stiff problems, RK45 for general ones [OK]

Common Mistakes:

• Confusing RK45 as best for stiff problems
• Thinking Euler method is in solve_ivp
• Assuming Midpoint is a scipy method

2. Which of the following is the correct way to specify the RK45 method in solve_ivp?

easy

A. method='RungeKutta45'

B. method='rk45'

C. method='RK_45'

D. method='RK45'

Solution

1. Step 1: Check method parameter syntax

   The solve_ivp function expects method names as strings exactly matching documented names.

2. Step 2: Verify correct spelling and case

   The correct method name is 'RK45' with uppercase letters and no underscores or spaces.

3. Final Answer:

   method='RK45' -> Option D

4. Quick Check:

   Exact method name = 'RK45' [OK]

Hint: Use exact method names with correct case in solve_ivp [OK]

Common Mistakes:

• Using lowercase 'rk45' instead of 'RK45'
• Adding underscores like 'RK_45'
• Using descriptive names not accepted by solve_ivp

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

from scipy.integrate import solve_ivp
import numpy as np

def fun(t, y):
    return -2 * y

sol = solve_ivp(fun, [0, 2], [1], method='RK45', t_eval=[0, 1, 2])
print(sol.y[0])

medium

A. [1. 0.13533528 0.01831564]

B. [1. 0.5 0.25]

C. [1. 2. 4.]

D. [0. 0. 0.]

Solution

1. Step 1: Understand the ODE and solution

   The ODE is dy/dt = -2y with initial y(0)=1, which has exact solution y(t) = exp(-2t).

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

   y(0)=1, y(1)=exp(-2) ≈ 0.1353, y(2)=exp(-4) ≈ 0.0183.

3. Final Answer:

   [1. 0.13533528 0.01831564] -> Option A

4. Quick Check:

   exp(-2t) at t=0,1,2 = [1. 0.13533528 0.01831564] [OK]

Hint: Use exact solution exp(-2t) to check output array [OK]

Common Mistakes:

• Confusing exponential decay with linear decay
• Misreading t_eval points
• Assuming RK45 returns integers

4. Identify the error in this code using BDF method:

from scipy.integrate import solve_ivp

def f(t, y):
    return y - t**2 + 1

sol = solve_ivp(f, [0, 2], 0.5, method='BDF', t_eval=[0, 1, 2])
print(sol.y)

medium

A. Function f must take only one argument

B. Initial condition y0 should be a list or array, not a float

C. Method 'BDF' is not supported in solve_ivp

D. t_eval must be a numpy array, not a list

Solution

1. Step 1: Check initial condition format

   The initial condition y0 must be an array-like object, even if single value, e.g., [0.5].

2. Step 2: Verify given y0 type

   Here y0 is given as 0.5 (float), which is not array-like and causes error.

3. Step 3: Confirm other parameters

   Function f has correct signature, method 'BDF' is valid, t_eval can be list or array.

4. Final Answer:

   Initial condition y0 should be a list or array, not a float -> Option B

5. Quick Check:

   y0 must be array-like [OK]

Hint: Always pass y0 as list or array, not single float [OK]

Common Mistakes:

• Passing y0 as float instead of list
• Thinking BDF is unsupported
• Believing t_eval must be numpy array

5. You want to solve a stiff ODE system and compare solutions from RK45 and BDF methods. Which approach correctly compares their results at specific times?

hard

A. Use only RK45 since BDF is slow and ignore BDF results

B. Run RK45 without t_eval and BDF with t_eval, then compare sol.t arrays

C. Use solve_ivp with t_eval for both methods, then compare sol.y arrays at those times

D. Compare the initial conditions only, since methods differ internally

Solution

1. Step 1: Understand comparison requirements

   To compare solutions, evaluate both methods at the same time points using t_eval.

2. Step 2: Use solve_ivp with t_eval for both

   Passing t_eval ensures outputs have matching time points, so sol.y arrays can be directly compared.

3. Step 3: Reject incorrect approaches

   Not using t_eval leads to different time points; ignoring BDF or comparing only initial conditions misses solution differences.

4. Final Answer:

   Use solve_ivp with t_eval for both methods, then compare sol.y arrays at those times -> Option C

5. Quick Check:

   Same t_eval for both = valid comparison [OK]

Hint: Use t_eval to get matching time points for comparison [OK]

Common Mistakes:

• Not using t_eval for both methods
• Comparing sol.t arrays instead of sol.y
• Ignoring BDF results due to speed concerns