Day 26 in Mat360

Today:

• Announcements:

  • Sorry -- I've not done any grading in the last two days. I'll hope to have everything back by Tuesday.

  • You have a homework assignment, due today -- breaking my poor, innocent Adaptive Quadrature code (what have you got against my code?).

  • Your Bezier curve project is due the last day of classes, which is Thursday of next week.

  • Today we'll see how to extend Euler's method to higher-order Taylor methods, and Tuesday we'll take a look at Runge-Kutta methods.

    You might read through 8.5 for next (RK methods).

  • As discussed last time, I'll add a small Mathematica component to the final, covering integration/ODEs. This will be assigned the last day of class. It will be a relatively routine comparison of solvers for integration and ODEs on a couple of problems.

• Review: ODEs and Euler's method
  • I'm not going to spend much time on the analytic stuff. You've all had a course in DEs, so hopefully that part makes sense to you. But you may be a bit rusty. In that case, you might check out Andy's "DEs in a Day" page.

    I may be making a few references to that page as we go along. Let's start with this one (about what we're actually solving, or attempting to solve).

    The upshot is expressed well in the authors' quote that "...the numerical solution values and do not lie on the true solution. In fact, they do not even lie on the same solution."

  • Let's pick up then on p. 321. Euler's method is the simplest, sanest starting point, and it can be derived in two different ways:
    1. By integrating (p. 321), or
    2. As a tangent line approximation (Figure 8.10, p. 322) -- which, by the way, is the same as using a Taylor series.

  • The method as a recursive algorithm is highlighted on p. 323 (box equation). Note that the step-size is also a function of and can vary. So you might start thinking about adaptive step-size control right away....

  • Let's have a look at the code on p. 323.

  • An example for the non-autonomous equation
    • We can solve this one analytically by separation of variables.
    • Let's compare some numerical solutions.
    • How should you feel about your numerical solution, if you didn't have the exact solution to compare them to?
    • The obvious question is this: "How should we choose the step size(s)?"

  • Now, as usual, we want to talk about errors (a function of step-size). Let's face it: we're clearly making errors.

    Start by taking a peak at Figure 8.13, p. 325. It illustrates everything that we want to consider.

    Our author distinguishes three types of error: in this figure there are two,

    • local discretization error, and
    • global discretization error.
    In addition we need to be concerned about rounding error.

    I want to prove a result which gives a bound on the error we're making (ignoring rounding error):

    

    We could use this formula to find a maximum step-size to take to control for a given global error , by bounding the total error at the right endpoint, :

    .

    Compare this to the result at the bottom of p. 326. They claim that the global discretization error is proportional to .

    If you expand the exponential in a Taylor series, you'll get

    . (We're in the ballpark!)

    A rough guide, then, for a step-size would be

    

  • However Making h small may not be a good idea if we add in the rounding error.

    

    The neat thing is that we can arrive at an optimal to reduce the error at the end of interval, when ,

    

    provided we can bound the second derivative and the rounding errors:

    

    Questions:

    1. Why does this make sense?
    2. Will this choice get us below ?

• Systems of ODEs
  • I don't want to dwell on systems too much, but we should at least note how easy it is to use Euler's method (and these more general methods we're about to consider) on a system.

  • Let's look at a couple of examples:
    • Rabbits and Foxes (pp. 330--; see page 336, in particular; this is traditionally called a Lotka-Volterra system, a simple example of predator-prey equations)
    • The Lorenz Equations (chaos)

    What we notice in the Rabbits and Foxes example is that Euler doesn't do a very good job. In the phase plane, the cycle is not closed (whereas it appears to be for NDSolve -- so maybe Mathematica's routine is better than Euler!:).

  • Second-order (and higher) ODEs can be turned into systems of first-order DEs, so if we can handle systems of first-order DEs, we're good to go: and it appears that we are, from our previous examples of rabbits, foxes, and chaos.

    Let's look at an example: the harmonic oscillator (a simplification of the simple pendulum).

• Now on to higher-order Taylor methods
  • Euler's method is an example of a Taylor method -- it's the first in a series (we might call it "Taylor-1"). So it's our introduction to Taylor methods, which we can think of as generalizations of Euler's method.

    In particular, we generalize the formula on p. 323,

    

    to the more general formula

    

    Note the parameter in the function: will generally be a function of .

  • As we saw last time, Euler can be derived as the tangent line approximation to solution of the ODE. We could just as easily pass a quadratic through the point that interpolates the slope and the curvature (2nd derivative) as well (Figure 8.19, p. 340). This is the idea behind Taylor-2.

    And so on! That's the idea of the higher-order Taylor methods.

    Let's have a look at a derivation with a slightly different emphasis from that in our text (our authors want to avoid partial derivatives, but I don't!).

    Examples:

    1. Computer problem #1, p. 344 (I'm not sure why the authors suggest the step-size control that they do -- they seem to be off by a power of , and a derivative.)
    2. A modification of that code to do other examples, e.g. Example 8.10, p. 340