# Time-Stepping Methods

Was introduced to this in CS370.

Time-stepping applies a Recurrence Relation to approximate the function values at later and later times.

- Given $y_{0}$, approximate $y_{1}$. Given $y_{1}$, approximate $y_{2}$. etc.

There are several varieties/categories of time-stepping methods:

*Single-step*vs.*Multistep*: do we use information only from the current time, or from previous timesteps too?*Explicit*vs.*Implicit*: Is $y_{n+1}$ given as an explicit function to evaluate, or do we need to solve an implicit equation?- Timestep size: Do we use a constant timestep $h$, or allow it to vary?

Methods:

- Forward Euler Method (explicit, single step)
- Trapezoidal Rule (implicit)
- Improved Forward Euler (explicit)
- Backward Euler
- Runge-Kutta Method
- Backwards Differentiation Formula (multi-step)

### Implicit vs. Explicit Function

e.g., given $x$ and $z$, determine $y$. Explicit function ($y$ only on one side): $y(x,z)=2x_{2}+g(z)β$

- Easy β just evaluate

Implicit function ($y$ on both sides): $y=x_{3}+17zx_{2}+sin(yβ)$

- Harder β requires solving

### Explicit vs. Implicit schemes

Explicit vs. Implicit Schemes

Explicit:

- Simpler, and fast to compute per step.
- Less stable β require smaller timesteps to avoid βblowing upβ. (More later!)

Implicit:

- Often more complex and expensive to solve per step.
- More stable β can safely use larger timesteps.