For second-order problems like (4) in which f depends only on x, the second-order Leapfrog integration scheme is widely used. Its simplicity makes it an attractive alternative. However, it requires us to make a modification to the way we have been thinking about how -- and when -- our data are defined.
Up to now, we have assumed (quite reasonably) that all data are
synchronous -- that is, all the components of the vector 
are
defined at the same time 
. However, in second-order systems at
least, it is often advantageous to define the velocities ( v =
dx/dt) at the mid-points of the intervals -- the velocities
are said to be staggered with respect to the positions x.
Setting aside for the moment how this is accomplished in practice, let
us define, following our earlier convention,
With this definition, we can write down a statement of the Leapfrog
scheme that advances 
to 
and 
to 
:
It is depicted graphically below. Notice the symmetry between the ways x and v are advanced in time. You can easily verify by expanding out the Taylor series
that this scheme does indeed give second-order accuracy in x. In fact, it is formally equivalent to the Mid-point or second-order predictor-corrector methods.
Of course, initial conditions are rarely specified at the staggered
times required by the leapfrog scheme! Typically, we must use a
so-called ``self-starting'' scheme (like Euler, Mid-point or
Runge-Kutta-4) to take the first half step and establish the value of
. The program
leapfrog.c implements the leapfrog scheme for the
inverse-square problem studied earlier. The program
simple_leapfrog.c applies leapfrog to a simpler 1-D problem.
Both use the Euler method to offset the initial velocity. You should
verify that this integrator really is second-order.
You might well ask, ``Since we have to start off with one of the other schemes anyway, and since the Mid-point method is already very simple to program, why should I ever bother with the Leapfrog scheme?'' The answer is that, unlike any of the other methods we have described, the Leapfrog integrator is time reversible -- and that property gives it some very important advantages.
To see the time reversibility explicitly , reconsider equation
(24) and imagine that we wished to ``reverse our tracks''
and step backward from 
to 
. Applying the algorithm, we do the following:
But these are precisely the steps (in reverse) that we took to advance the system in the first place! In other words, if we use the Leapfrog scheme to integrate forward in time, then reverse the velocities (and the sign of the timestep) and use the same integrator to return to time t = 0, we will arrive precisely our starting point -- not approximately, as would be the case with the other integrators, but exactly, at least up to rounding error. Verify this for yourself by modifying leapfrog.c to reverse itself and integrate backwards after integrating forward for some interval -- 10 time units, say.
The Leapfrog scheme is time reversible because of the symmetric way in which it is defined. None of the earlier schemes have this property, because they all evaluate derivatives in an asymmetrical way. For example, in the Euler method, it is clear that the forward and backward steps would not cancel out precisely -- they use different derivatives, evaluated at different times. In the Mid-point method, which uses an estimate of the derivative at the center of the range, that estimate is still based on an extrapolation from the left-hand side of the interval. On time reversal, the corresponding estimate would be based on the derivative at the right-hand edge, and would not yield precisely the same result. The difference is small, but it is enough to prevent the scheme from being exactly time reversible. Similar reasoning applies to Runge-Kutta-4.
Time reversibility is important because it guarantees
conservation of energy, angular momentum -- and any other conserved
quantity -- in many cases. Consider again the problem of a simple
elliptical solution of the gravitational two-body problem. Imagine
that our integrator makes an energy error of 
as it
integrates the system forward through 1 orbital period. Now imagine
reversing the integration. You might guess that the energy error in
the reverse integration would be 
, but this is not
the case. In any system where the equations of motion are unchanged by
time reversal (and, specifically, in any case where the function
f depends only on the coordinates), the time-reversed orbit is itself
a solution of the original ODE (with v simply replaced by
-v), so the energy error is still 
. But if our
itegration scheme is time-reversible, we know that the final energy
error is zero (because we return to our starting point). The only
possible way that this can occur is if 
(i.e. energy is
exactly conserved!).
You can demonstrate for yourself the difference in energy conservation between the various methods we have discussed by plotting the energy error as a function of time for the standard initial conditions used in the earlier program inverse_square.c. As illustrated below, even the small error (exaggerated here by choosing a timestep 5 times greater than in the other two integrators) made by Runge-Kutta-4 is systematic, leading to a long-term drift in the orbital parameters, the energy error in the Leapfrog scheme has no such long-term trend. There is a periodic error over the course of an orbit, at the same level as the error in the Mid-point scheme, but the errors incurred over the outgoing portion of the orbit exactly cancel those produced on the incoming segment, so no net error results. The Leapfrog method is only second-order accurate, but it is very stable.
In situations where we are interested in long-term small changes in the properties of a nearly periodic orbit, and where even small systematic errors would mask the true solution, time-reversible integrators such as the Leapfrog scheme are essential.
