The Euler and trapezoidal stencils to solve d d x y x = f x, y x

Transcription

1 restart; Te Euler and trapezoidal stencils to solve d d x y x = y x Te purpose of tis workseet is to derive te tree simplest numerical stencils to solve te first order d equation y x d x = y x, and study some of teir properties. We first write down te ODE using te D notation: ode := D(y)(x) = f(x,y(x)); ode := D y x = y x In tis expression, f is assumed to be a known function of te independant variable x and te function tat we are trying to solve for y x. Te simplest numerical stencils to solve tis equation will give us an approximation to y at some point x = X C given some knowledge of y at x = X. All of tese stencils are based on te Taylor series approximation for y x about x = X to linear order: eq1 := y(x) = series(y(x),x=x,); eq1 := y x = y X C D y X x K X C O x K X Let us define as te difference between x and X, and ten get rid of x in te above expression: eq := = x - X; eq3 := subs(isolate(eq,x),eq1); eq := = x K X eq3 := y C X = y X C D y X C O Now, we can remove te first derivative of y by making use of te differential equation: eq4 := subs(x=x,ode); eq5 := subs(eq4,eq3); eq4 := D y X = f X, y X eq5 := y C X = y X C f X, y X C O Te forward Euler algoritm involves discarding te terms of order and iger in tis expression and ence obtain an approximation to y X C in terms of y X. We can accompis tis by converting te above series into a polynomial using te convert/polynom command. Also, we can take X = x i as te i t point on an evenly spaced lattice x i = x 0 C i, were is te lattice spacing and i is an integer; it ten follows tat X C = x i C 1. Furtermore, we label te numeric approximation of y x at x = x i as y i z y x i. Implementing tese steps and notational canges: eq6 := convert(eq5,polynom); eq7 := [y(+x)=y[i+1],y(x)=y[i],x=x[i]]; eq8 := subs(eq7,eq6); eq6 := y C X = y X C f X, y X eq7 := y C X = y i C 1, y X = y i, X = x i (1) () (3) (4) eq8 := y i C 1 = y i C f x i, y i (5) Te last expression is te forward Euler stencil for solving ode. It is called an explicit algoritm because te quantity we wis to calculate y i C 1 is given explicitly in terms of y i. Te backward Euler stencil is

2 obtained in a similar fasion, except we identify, y i, and y i C 1 differently: eq9 := = X - x; eq10 := subs(isolate(eq9,x),eq1); eq11 := subs(eq4,eq10); eq1 := convert(eq11,polynom); eq13 := [y(-+x)=y[i],y(x)=y[i+1],x=x[i+1]]; eq14 := subs(eq13,eq1); eq9 := = X K x eq10 := y K C X = y X K D y X C O K eq11 := y K C X = y X K f X, y X C O K eq1 := y K C X = y X K f X, y X eq13 := y K C X = y i, y X = y i C 1, X = x i C 1 eq14 := y i = y i C 1 K f x i C 1 (6) Tis stencil is explicit because it will not in general be possible to alegraically isolate wat we want to calculate, i.e. y i C 1 z y x i C 1, except for very specific forms of f. We can rearrange te stencils to better demonstrate teir geometric meaning: ForwardEuler := collect(expand(isolate(eq8,f(x[i],y[i]))),); BackwardEuler := collect(expand(isolate(eq14,f(x[i+1],y[i+1]))),); ForwardEuler := f x i, y i BackwardEuler := f x i C 1 Tese forms illustrate tat te forward Euler stencil (first equation) is a simple approximation of te first derivative of y x in te interval x x i, x i C 1 using ode evaluated at te leftand side of te interval. Conversely, te backward Euler stencil uses te differential equation to evalulate te derivative at te rigtand side of te interval. Tere is anoter stencil we can derive tat is te average of tese two approaces: Trapezoidal := (ForwardEuler+BackwardEuler)/; Trapezoidal := 1 f x i, y i C 1 f x i C 1 Tis is called te trapezoidal metod, and it uses ode evaluated at bot ends of te interval to approximate y' x. Like te backward Euler stencil, it represents an implicit sceme. As an example, we can look at wat tese stencils look like for te special case of y = ly were λ is a constant: f := (x,y) - lambda*y; Stencils := [ForwardEuler,BackwardEuler,Trapezoidal]; Labels := ["Forward Euler","Backward Euler","Trapezoidal"]; f := x, y /l y Stencils := l y i Labels :=, l y i C 1, 1 l y i C 1 l y i C 1 "Forward Euler", "Backward Euler", "Trapezoidal" For tis special case, we see tat it is possible to isolate y i C 1 for eac stencil. Let's do tis using a loop: (7) (8) (9)

3 for j from 1 to 3 do: Stencils[j] := factor(isolate(stencils[j],y[i+1])): print(labels[j],stencils[j]): "Forward Euler" = y i l C 1 "Backward Euler" = K l K 1 "Trapezoidal" = K y i Now, lets go back to te general case by undefining f: f := 'f'; Stencils := [ForwardEuler,BackwardEuler,Trapezoidal]; f := f Stencils := f x i, y i y i l C l K, f x i C 1, 1 f x i, y i (10) (11) C 1 f x i C 1 We now want to determine wat te error is in eac stencil. To do tis, we need to rewrite eac of tem in te standard form y i C 1 Ky i KF x i, x i C 1, y i = 0: for j from 1 to 3 do: Stencils[j] := Stencils[j]* + y[i]; Stencils[j] := (rs-ls)(stencils[j])=0; print(stencillabels[j],stencils[j]): StencilLabels 1 K y i K f x i, y i = 0 StencilLabels K f x i C 1 K y i = 0 StencilLabels 3 K 1 f x i, y i C 1 f x i C 1 K y i = 0 Note tat tese relations define our numeric stencils in tese sense tat tey give exact relations between te approximations y i and y i C 1. But if we replace te approximations wit te exact values of y x tey are supposed to represent, te above will represent only approximate equalities. Tat is, if we make te canges x i / x, x i C 1 / x C, y i / y x / y x C, te leftand sides of te above equations will only be approximately equal to zero. We call te magnitude of te discrepancy te "one step error" or "local error" in te stencil. Hence, te one step error in te various stencils will be: eq15 := [y[i]=y(x),y[i+1]=y(x+),x[i]=x,x[i+1]=x+]; for j from 1 to 3 do: Error[Labels[j]] := subs(eq15,ls(stencils[j])); od; eq15 := y i = y x = y x C, x i = x, x i C 1 = x C Error "Forward Euler" := y x C K y x K y x Error "Backward Euler" := y x C K f x C, y x C K y x (1) (13)

4 Error "Trapezoidal" := y x C K 1 y x C 1 f x C, y x C K y x To estimate te magnitudes of tese errors, we expand eac of te above expression as a power series about = 0 (since we are implicitly assuming is a small quantity): for j from 1 to 3 do: Error[Labels[j]] := series(error[labels[j]],,4); od; Error "Forward Euler" := K y x C D y x C 1 D y x C 1 6 D 3 y x 3 C O 4 (13) Error "Backward Euler" := K y x C D y x C 1 D y x K D 1 y x K D y x D y x C 1 6 D 3 y x K 1 D 1, 1 f x, y x K D 1, y x D y x K 1 D, y x D y x 3 C O 4 y x D y x K 1 D Error "Trapezoidal" := K y x C D y x C 1 D y x K 1 D 1 (14) y x K 1 D y x D y x C 1 6 D 3 y x K 1 4 D 1, 1 y x K 1 D 1, y x D y x K 1 4 D, y x D y x K 1 4 D y x D y x 3 C O 4 Notice tat first, second and tird derivatives of y appear explicitly in tese expressions. Te first derivative terms can be removed by making use of ode. Te second derivative can also be removed by examining te derivative of ode: eq16 := diff(ode,x); eq17 := convert(ode,diff); eq18 := subs(eq17,eq16); eq16 := D y x = D 1 y x C D y x eq17 := d dx y x = y x d dx y x eq18 := D y x = D 1 y x C D y x y x Similarly, te tird derivative can be removed by differentiating eq18: eq19 := subs(eq17,diff(eq18,x)); eq19 := D 3 y x = D 1, 1 y x C D 1, y x y x (15) (16)

5 C D 1, y x C D, y x y x y x C D y x D 1 y x C D y x y x We now substitute our formulae for te derivatives of y into te error expressions: for j from 1 to 3 do: Error[Labels[j]] := subs(eq18,eq19,ode,error[labels[j]]); od; 1 Error "Forward Euler" := D y x C 1 1 D y x y x C 1 6 D 1, 1 y x C 1 6 D 1, y x y x C 1 6 D 1, y x C D, y x y x y x C 1 6 D y x D 1 y x C D y x y x 3 C O 4 Error "Backward Euler" := K 1 D 1 y x K 1 D y x y x C K 1 3 D 1, 1 y x K 5 6 D 1, y x y x C 1 6 D 1, y x C D, y x y x y x K 1 3 D y x D 1 y x C D y x y x K 1 D, y x y x 3 C O 4 Error "Trapezoidal" := K 1 1 D 1, 1 y x K 1 3 D 1, y x y x (17) C 1 6 D 1, y x C D, y x y x y x K 1 1 D y x D 1 y x C D y x y x K 1 4 D, y x y x 3 C O 4 We see tat te local error for te forward and backward scemes is O. Futermore, te leading order terms for tose stencils is te negative of te oter one. Since te trapezoidal sceme is te average of te forward and backward algoritms, tis explains wy te leading order error for te trapeziodal sceme is O 3. In oter words, te trapezoidal sceme is more accurate tan te oter two. Note tat if all we are after is te magnitude of te leading order terms in te errors, we can just expand te above in a low order series: for j from 1 to 3 do: Error[Labels[j]] := series(error[labels[j]],,0); od;

6 Error "Forward Euler" := O Error "Backward Euler" := O Error "Trapezoidal" := O 3 (18) We now turn our attention to actual numerical algoritms employing tese stencils. Since te forward Euler sceme is explicit, it is particularly easy to develop some code for it tat works for arbitrary functions f. It is useful to rewrite te stencil wit y i C 1 isolated on te LHS: eq0 := isolate(stencils[1],y[i+1]); eq0 := y i C 1 = y i C f x i, y i Now we can transcribe tis as a mapping tat takes te stepsize and te old values of y i and x i and returns te new value y i C 1 : y_new := (,x_old,y_old) - y_old + f(x_old,y_old)*; y_new :=, x_old, y_old /y_old C f x_old, y_old We could ave equivalently accomplised tis by using te unapply command, wic converts expression into mappings witout aving to re-write tem manually: y_new := unapply(rs(eq0),,x[i],y[i]); y_new :=, y, y3 /y3 C f y, y3 Here is a procedure EulerSol tat calculates te numerical solution of ode in te interval x 0, 1 once te form of y as been fixed. It's arguments are initial data in te form y 0 = y0 and te number of steps N. Te output is a list of points, wic we compare in te plot to te output generated by dsolve/numeric for te same problem. f := (x,y) - -y^+*x; ode; y0 := ; N := 15; EulerSol := proc(y0,n) local, x, y, i: end proc: := evalf(1/n): x[0] := 0: y[0] := y0: for i from 1 to N do: x[i] := x[i-1] + : y[i] := y_new(,x[i-1],y[i-1]): [seq([x[i],y[i]],i=0..n)]: data := EulerSol(y0,N); dsolvesol := rs(dsolve({ode,y(0)=y0},numeric,output=listprocedure) []); plot([data,dsolvesol(x)],x=0..1,axes=boxed,legend=[`forward Euler`, `dsolve/numeric`]); f := x, y /Ky C x (19) (0) (1)

7 D y x = Ky x C x y0 := N := 15 data := 0,, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , dsolvesol := proc x... end proc x Forward Euler dsolve/numeric Of course, tis plot is really comparing te results of two numeric approximations to te true solution of te problem. It is also useful to compare numeric answers to analytic results (if available). For te above coice of y tere is an analytic solution in terms of Airy functions: analytic_sol := dsolve({ode,y(0)=y0}): analytic_sol := rs(analytic_sol); ()

8 analytic_sol := 1 / 3 K4 p 3 5 / 6 C 3 1 / 3 G 3 4 p 3 1 / 3 C 3 1 / 3 G 3 3 / 3 AiryAi 1, 1 / 3 x 3 1 / 6 C AiryBi 1, 1 / 3 x () K4 p 3 5 / 6 C 3 1 / 3 G 3 4 p 3 1 / 3 C 3 1 / 3 G 3 3 / 3 AiryAi 1 / 3 x 3 1 / 6 C AiryBi Here is some code tat generates a movie comparing ow te numerical solution converges to te analytic solution as te number of cells is increased: for j from 1 to 5 do: N := 4*j: p[j] := plot([eulersol(y0,n),analytic_sol],x=0..1,title = cat (`number of cells N = `,N),axes=boxed,legend=[`Forward Euler solution`,`analytic solution`],style=[point,line]); plots[display](convert(p,list),insequence=true); 1 / 3 x

9 number of cells N = explicitly: x Forward Euler solution analytic solution We would also like to examine te performance of te backward and trapezoidal stencils, so let's make a simple coice of y tat admits an analytic solution allows eac stencil to be solve for y i C 1 f := (x,y) - lambda*y; y0 := 'y0'; ode; analytic_sol := rs(dsolve({ode,y(0)=y0})); for j from 1 to 3 do: Stencils[j] := isolate(stencils[j],y[i+1]); print(labels[j],stencils[j]); f := x, y /l y y0 := y0 D y x = l y x analytic_sol := y0 e l x "Forward Euler" = l y i C y i

10 "Backward Euler" = y i 1 K l "Trapezoidal" = y i C 1 l y i 1 K 1 l (3) As for te above code, it will be useful to realize eac stencil as a mapping wit arguments, l and y i. We can do tis using a loop and te unapply command: for j from 1 to 3 do: stencil[j] := unapply(rs(stencils[j]),,lambda,y[i]); od; stencil 1 :=, l, y3 /l y3 C y3 stencil :=, l, y3 / y3 1 K l y3 C 1 l y3 stencil 3 :=, l, y3 / 1 K 1 l (4) Conversely, we could ave accomplised te same ting in one line by using te map command, wic applies te same mapping onto eac element of a list (in tis case we are applying operations onto eac element of Stencils to generate a new list stencil): stencil := 'stencil': stencil := map(u-unapply(rs(u),,lambda,y[i]),stencils); stencil :=, l, y3 /l y3 C y3,, l, y3 / y3 y3 C 1 l y3,, l, y3 / 1 K l 1 K 1 l It is interesting to note tat even toug eac of te stencils give different expressions for y i C 1, tey actually agree wit one anoter to order. To see tis, let's perform some Taylor series expansions: for j from 1 to 3 do: Labels[j],y[i+1] = series(stencil[j](,lambda,y[i]),,); od; "Forward Euler" = y i C l y i "Backward Euler" = y i C l y i C O "Trapezoidal" = y i C l y i C O Now, ere is a procedure EulerSol tat calculates a numeric solution for y x for x 0, 1 using N cells and assuming y 0 = y0 and a given value of λ. Te value of coice dictates wic stencil is used: 1 for forward Euler, for backward Euler, and 3 for trapezoidal. EulerSol := proc(y0,n,lambda,coice) local, x, y, i: (5) (6)

11 := evalf(1/n): x[0] := 0: y[0] := y0: for i from 1 to N do: x[i] := x[i-1] + : y[i] := stencil[coice](,lambda,y[i-1]): [seq([x[i],y[i]],i=0..n)]: end proc: Here is a plot of te numeric output for eac stencil compared to te actually solution. (Because we are going to plot 4 curves on our grap, I needed to augment Labels into NewLabels in order to gereate te legend.) It seems as if te trapezoidal metod performs muc better tan te oter two: N := 15; y0 := ; lambda := -4; NewLabels := [op(labels),"analytic solution"]; plot([seq(eulersol(y0,n,lambda,j),j=1..3),analytic_sol],x=0..1, legend=newlabels,axes=boxed,style=[point$3,line]); N := 15 NewLabels := y0 := l := K4 "Forward Euler", "Backward Euler", "Trapezoidal", "analytic solution"

12 x Forward Euler Backward Euler Trapezoidal analytic solution We can quantify exactly ow well te various stencils are doing by comparing te numeric and actual values for y at some fixed value o say x = 1. We call tis te global error in te numeric solution at x = 1, wic we denote by ϵ: epsilon := proc(y0,n,lambda,coice) local numerical, actual: numerical := EulerSol(y0,N,lambda,coice)[N+1][]: actual := y0*exp(lambda): evalf(abs(numerical - actual)): end proc: In tis procedure, note tat te [N+1][] suffix after EulerSol(y0,N,lambda,coice) as te effect of picking out te last element of te list (wic is itself a list of quantities), and ten picking out te second element of tat sub-list (wic is te numerical answer for y 1 ). We now generate a log-log plot of te global errors for eac stencil as a function of N: data := 'data': for j from 1 to 3 do: data[j] := [seq([n,epsilon(y0,n,lambda,j)],n= ,5)];

13 plots[loglogplot](convert(data,list),axes=boxed,labels=[`number of steps`,`global error`],legend=labels); global error number of steps Forward Euler Backward Euler Trapezoidal For N T 100, te error curves look linear on tis log-log plot. Tis implies tat above some tresold number of steps, te errors obey a approximate power law e z an b were a and b are constants. We can determine te values of tese parameters by fitting a power law to our error data using Statistics/PowerFit. We first need to regenerate our data for N R 100; i.e., te range for wic we believe a power law ougt to be valid: data := 'data': for j from 1 to 3 do: data[j] := [seq([n,epsilon(y0,n,lambda,j)],n= ,5)]; We ten use te Statistics[PowerFit] command to perform te fit. Note tat tis function requires te input to be a matrix, wic is wy we use te convert/matrix structure. Te raw output of te fitting algoritms is sown for eac stencil, as well as te value of b in te power-law e z an b. for j from 1 to 3 do: fit[j] := Statistics[PowerFit](convert(data[j],Matrix),_N, output=[leastsquaresfunction,parametervalues]): print(labels[j],fit[j],b=fit[j][][]);

14 "Forward Euler", K "Backward Euler", "Trapezoidal", _N , K K _N , K K _N , K K , b =, b = K , b = K We see tat for asyptotically large numbers of steps N [ 1, te global errors are O N K1 = O for te forward and backward Euler stencils, and O N K = O for te trapezoidal metod. Tis confirms te general expectation tat for a stencil wit one step error O p, we expect te global error to obey global error w (number of steps)#(one-step error for eac step) = N # O p = O K1 # O p = O p K 1. [Recall tat we sowed in (18) above tat p = for forward and backward Euler, and p = 3 for te trapezoidal algoirtm.] NOTE: te above syntax for Statistics[PowerFit] only works in Maple 15. For previous versions, you need to do tis: for j from 1 to 3 do: M := convert(data[j],matrix): X := LinearAlgebra[Column](M,1): Y := LinearAlgebra[Column](M,): fit[j] := Statistics[PowerFit](X,Y,_N,output= [leastsquaresfunction,parametervalues]): print(labels[j],fit[j],b=fit[j][][]); "Forward Euler", _N , K , b = K K "Backward Euler", "Trapezoidal", _N , K K _N , K K , b = K , b = K (7) (8)