This document discusses numerical methods for solving ordinary differential equations (ODEs). It begins by introducing ODEs and their general form. It then discusses the Taylor series expansion used to derive common ODE solving methods. The document specifically examines the forward Euler and Runge-Kutta methods. It provides the equations for the forward Euler and a second-order Runge-Kutta method. It also includes two problems - the first asks to show the Runge-Kutta method captures second-order terms, and the second compares the error rates of forward Euler and Runge-Kutta on a test problem. Sample solutions and code are provided.
This document discusses numerical methods for solving ordinary differential equations (ODEs). It begins by introducing ODEs and their general form. It then discusses the Taylor series expansion used to derive common ODE solving methods. The document specifically examines the forward Euler and Runge-Kutta methods. It provides the equations for the forward Euler and a second-order Runge-Kutta method. It also includes two problems - the first asks to show the Runge-Kutta method captures second-order terms, and the second compares the error rates of forward Euler and Runge-Kutta on a test problem. Sample solutions and code are provided.
This document discusses numerical methods for solving ordinary differential equations (ODEs). It begins by introducing ODEs and their general form. It then discusses the Taylor series expansion used to derive common ODE solving methods. The document specifically examines the forward Euler and Runge-Kutta methods. It provides the equations for the forward Euler and a second-order Runge-Kutta method. It also includes two problems - the first asks to show the Runge-Kutta method captures second-order terms, and the second compares the error rates of forward Euler and Runge-Kutta on a test problem. Sample solutions and code are provided.
This document discusses numerical methods for solving ordinary differential equations (ODEs). It begins by introducing ODEs and their general form. It then discusses the Taylor series expansion used to derive common ODE solving methods. The document specifically examines the forward Euler and Runge-Kutta methods. It provides the equations for the forward Euler and a second-order Runge-Kutta method. It also includes two problems - the first asks to show the Runge-Kutta method captures second-order terms, and the second compares the error rates of forward Euler and Runge-Kutta on a test problem. Sample solutions and code are provided.
In simulating dynamical systems, we frequently solve ordinary differential equations. These are of the form dx = f (t, x), dt where the function f has as arguments both time and the state x. The time argument is used if the system is time-dependent (time-varying), but unnecessary if the system is time-invariant. Solving the differential equation means propagating x forward in time from some initial condition, say x(t = 0), and typically the solution will be given as a vector of [x(0), x(t), x(2t), ], where t is a fixed time step. The Taylor series is used to derive most of the simple formulas for solving ODEs. The general Taylor series expansion of the generic function g in two variables is g g g(t + t, x + x) = g(t, x) + t + x + t x 1 2g 2 1 2g 1 2g 1 2g t + tx + xt + x2 + . 2! t2 2! tx 2! xt 2! x2 In the above formula, when the arguments of g and its derivatives are not shown, we mean that it is to be evaluated at (t, x), that is g alone means g(t, x) and so on. We use this shorthand below in several places. The simplest of all the ODE methods is forward Euler, created by setting g = x and looking only at the first two terms on the right-hand side of the Taylor series: dx x(t + t) = x(t) + t = x(t) + tf dt This formula says that x at the next time instant is the current x plus the time step times the slope evaluated at the current x. Referring to the Taylor series, we see that the forward Euler does not do anything with the second-order terms (t2 and beyond), and so we say the method is second-order accurate in the step, which will turn out to be first-order accurate when you solve a real problem with many steps. First-order means that if you halve the time step, you can expect about half the error in the overall simulation. An alternative, the Runge-Kutta methods are popular workhorses, and implemented in the MATLAB commands ode23() and ode45(). Lets take a look at the first of these: The rule is k1 = tf k2 = tf (t + t/2, x(t) + k1 /2) x(t + t) = x(t) + k2 .
We see that k1 is the same change in x as given by the forward Euler rule. k2 is another guess for the change in x, but with the slope calculated at the approximate midpoint [t + 13 NUMERICAL SOLUTION OF ODES 29
t/2, x(t) + k1 /2]. You can guess that this will be a somewhat more accurate result. Note, however, that we have to evaluate the function twice in each time step, as opposed to once each time step for the forward Euler method. Here are your two problems:
1. The listed Runge-Kutta algorithm is third-order accurate in the step and second-order accurate in the whole: in each step, we get a cancelation of all the second-order terms in the Taylor series! Can you gure out how to show this? Solution: We have to show that the Runge-Kutta formula captures up to second-order terms in the Taylor series. First, the formula for k2 is itself approximated as a Taylor series:
k2 = tf (t + t/2, x + k1 /2)
t f k1 f = t f + + + h.o.t. 2 t 2 x
t f t f = t f + + f + h.o.t. , 2 t 2 x
where we again assume evaluation of functions at x(t) and t when the argument is omitted. The rst relation comes from the bivariate Taylor series, and the second by substituting in k1 . The acronym h.o.t. stands for higher-order terms. Next, write out x(t + t) according to the last line of the RK2 rule:
x(t + t) = x + k2
t2 f f = x + tf + + f + h.o.t. 2 t x
You recognize the rst two terms in the square brackets here as the total derivative of (bivariate) f with t, which is the second derivative of x with time. How does this result look compared to the direct Taylor series for x? We have for the univariate Taylor series applied to x: dx t2 dx2 x(t + t) = x + t + + h.o.t. dt 2 dt2 So the RK2 formula does indeed capture the rst- and second-order terms of the Taylor series. Note that the h.o.t. that appears when we worked with k2 is not the same as the h.o.t. that appears in the direct expansion of x - so we cannot claim that the third-order terms are captured in the RK2 rule. RK4 (shown below) captures both the third- and fourth-order terms! 2. Compare the error convergence rates, for the forward Euler and the second-order Runge-Kutta on the simple problem dx/dt = x, x(t = 0) = 1. To do this, you will make several simulations with each method, over the time scale [0, 5], and with 13 NUMERICAL SOLUTION OF ODES 30
t = [0.0125 0.025 0.05 0.10 0.20 0.50 1.00]. For each, record the maximum absolute error with respect to the exact solution (a decaying exponential), and then make a summary plot of t versus error, including both methods. You should be able to see the first-order convergence of forward Euler and the second-order convergence of RK2.
As an aside, forward Euler has stability problems that are more severe than for the Runge- Kutta family, and this is another reason why forward Euler should usually not be your first choice. Please do not use the canned MATLAB ODE functions to solve the second problem. I am asking you to make the explicit calculations for programming practice, to see the error rates first-hand, and because we sometimes dont have MATLAB available where needed, e.g., on an embedded processor. Solution: See MATLAB results and code below. The Euler method is first-order: a ten- fold reduction in t gives a ten-fold reduction in error. RK2 is second-order: the ten-fold reduction in t gives a one-hundred-fold reduction in error. Most impressive, the RK4 is fourth-order so we get a ten-thousand-fold improvement for a ten-fold reduction in t. Note that RK4 requires four evaluations per time step, and RK2 requires two. But it is usually well worth it! Finally, notice that the RK2 and the forward Euler both give awful errors with t = 1. This is no surprise, since the time constant of the system is one also. The RK4 gives us a much better result here, the result of those extra evaluations.
