Initial value problems - Executable Engineering: Interactive Numerical Methods in Python

Initial Value Problems (IVPs) are characterized by knowledge of boundary conditions only on one side of the domain. This is typically (but not necessarily) for time-dependent equations, thus the name and following nomenclature, e.g.:

\frac{\mathrm{d}y}{\mathrm{d}t} = y, \quad y(t=0) = 1

(1)

\frac{\mathrm{d}^2 y}{\mathrm{d}t^2} = -g, \quad y(t=0) = 1000, \quad y'(t=0) = 0

(2)

import numpy as np
import plotly.graph_objects as go

try:
    import executable_engineering as exe
except ImportError:
    %pip install -q executable_engineering
    import executable_engineering as exe

Time-Stepping Forward in Domain¶

In these cases we are forced to start at $t=0$ and time-step forward until we reach our goal time. This has several implications:

Error in the solution will accumulate with successive steps.
Numerical noise may destabilize the solution scheme.
Time stepping must resolve the time-scale of the physics we are looking at.
The time-scale may change mid-problem.
We will build up a history of steps as we go.

As with analytical methods, on a high level we obtain a solution by integrating the differential equation up until the point of interest. For this reason, IVP solvers are often called time integrators and much of the quadrature analysis carries over.

Error Analysis¶

As usual, we will discuss error in the context of truncation error. As with other integration schemes:

Local truncation error occurs over a single time-step due to the approximation of $y_{i+1}$ .
Global / propagated truncation error is the accumulation of propagated local truncation error and results in overall error of the approximation compared to the true solution.

Later we will discuss a new phenomenon: stability and stiffness.

We will use the Taylor expansion to analyze error and help develop our numerical schemes. Higher accuracy is achieved through estimation of the higher-order derivatives. There are two classes of methods that are applied:

Single-step methods: Use information about the current time step (and potentially take internal substeps).
Multistep methods: Use the history of previous time steps.