= D ( )( ) derivative

Size: px

Start display at page:

Download "= D ( )( ) derivative"

Philippa Franklin
5 years ago
Views:

1 > restart; In this worksheet we are going to be considering the numeric solution of the following differential equation: > ode diff(y(x,x f(x,y(x; d ode dx y( x f ( x, y( x Here, f is taken to be a known function. Everything we do will follow from the Taylor series expansion of y(x: > series y(x+h series(y(x+h,h,4; series y ( x + h y( x + D( y ( x h + ( D ( ( y ( x h + ( D ( 3 ( y( x h 3 + O( h 4 The O(h^4 term represents all the terms in the Taylor series that are not explicitly written down. If we were to neglect all the missing terms, the RHS would give an approximation to y(x+h with an error that scales like h^4. We want to used the ode to remove derivatives of y in the above Taylor series. To do this, we need to express the ode using the D notation: > derivative[] convert(ode,d; derivative D( y ( x f ( x, y( x We also need expressions for the higher order derivatives of y in terms of f. These are obtained as follows: > for i from to 3 do: derivative[i] subs(seq(derivative[j],j..i-,convert(diff(derivative[i-],x,d: od; derivative ( D ( ( y ( x + f x, y( x D ( f ( x, y( x f ( x, y( x derivative 3 ( D ( 3 ( y ( x + ( f ( x, y( x f ( x, y( x + ( + ( f ( x, y( x f ( x, y( x f ( x, y( x + D ( D + D f ( x, y( x Notice how in the above, the expressions for lower order derivatives are used to simplify the expressions for the higher ones. Putting this into the original Taylor series expansion gives > series subs(convert(derivative,list,series; series y ( x + h y( x f ( x, y( x h + h, +, f x, y( x f ( x, y( x + ( + ( f ( x, y( x f ( x, y( x f ( x, y( x + f x, y( x ( D ( f ( x, y( x + D ( f ( x, y( x f ( x, y( x h 3 + O( h 4 This series expansion is entirely in terms of y(x and f. It will be convenient to re-arrange this so that all the terms of order h^ and above are on the right. First we execute the following: > series3 expand(series - convert(series(rhs(series,h,,polynom; series3 y ( x + h y( x f ( x, y( x h y( x f ( x, y( x h + f x, y( x h, f x, y( x + 3, +, + f x, y( x D ( f ( x, y( x + f ( x, y( x h 3 + O( h 4 y( x f ( x, y( x h We can make the RHS look nicer by expanding it in another Taylor series in h. To do this, we use the applyop command (lookup?applyop. Basically, applyop(series,,equation,h,n will perform a n^th order Taylor series expansion on the RHS of equation about h 0. > series4 applyop(series,,series3,h,4; series4 y ( x + h y( x f ( x, y( x h + h, + 3, f x, y( x f ( x, y( x +, f x, y( x f ( x, y( x + f x, y( x D + f x, y( x f ( x, y( x h 3 + O( h 4 Note that this expression holds for any x and h. So we can get another series expansion by putting h to -h and x to x+h:

2 > series5 subs(h-h,xx+h,series4; series5 y( x y ( x + h + f ( x + h, y ( x + h h + f x + h, y ( x + h f x + h, y ( x + h f ( x + h, y ( x + h ( h ( f ( x + h, y ( x + h + 3, f x + h, y ( x + h f ( x + h, y ( x + h + ( f ( x + h, y ( x + h f ( x + h, y ( x + h f x + h, y ( x + h D ( f ( x + h, y ( x + h f x + h, y ( x + h f ( x + h, y ( x + h ( h 3 + O (( h 4 Unlike series4, the RHS of this is not a simple polynomial in h due to the presence of terms like f(x+h,y(x+h. These can be removed by again re-expanding the RHS as a series: > series applyop(series,,series5,h,4; series y( x y ( x + h + f ( x + h, y ( x + h h + f x, y( x f ( x, y( x h f x, y( x ( D ( f ( x, y( x + D ( f ( x, y( x D( y ( x + ( ( f ( x, y( x + ( f ( x, y( x D( y ( x f ( x, y( x + 3, +, f x, y( x D( y ( x 3, ( f ( x, y( x f ( x, y( x f x, y( x D f x, y( x f ( x, y( x h 3 + O( h 4 series4 and series form the basis of our numerical scheme. We can use them to find an approximation to the value of y(x+h given knowledge of y(x. In this sense, the give us a "new" value of y from and "old" value. We re-label the various quantities accordingly: > Subs [y(x+hy_new,y(xy_old,x+hx_new,xx_old]: series7 subs(subs,series4; series8 subs(subs,series; series7 y_new y_old f ( x_old, y_old h + y_old y_old h y_old + 3, y_old + y_old f ( x_old, y_old y_old D y_old y_old f ( x_old, y_old h 3 + O( h 4 series8 y_old y_new + f ( x_new, y_new h + y_old y_old h y_old ( D y_old + D y_old D( y ( x_old ( ( f ( x_old, y_old + ( f ( x_old, y_old D( y ( x_old f ( x_old, y_old 3 +, y_old D( y ( x_old 3, y_old y_old y_old f ( x_old, y_old y_old D y_old y_old f ( x_old, y_old h 3 + O( h 4 The "stencil" for the so-called forward Euler scheme is obtained by discarding all the terms on the right of series7. This gives us an explicit formula for y_new in terms of y_old, accurate to order h: > ForwardEuler applyop(series,,isolate(series7,y_new,h,; ForwardEuler y_new y_old + f ( x_old, y_old h + O( h The same procedure on series8 yields another formula accurate to order h. But, in this formula one cannot explicitly solve for y_new because it appears as one of the arguments of f. Hence, this is an implicit stencil where the the new value of y must be obtained by solving an equation. > BackwardEuler applyop(series,,series8,h,; BackwardEuler y_old y_new + f ( x_new, y_new h O( h Another implicit scheme is obtained by subtracting series7 from series8. Notice that the h^ term in both is the same, so this subtraction removes the h^ error term, leaving a residual error of order h^3. But again, y_new is defined implicitly in terms of y_old. > Trapezoidal applyop(series,,(series7-series8/,h,3;

3 Trapezoidal y_new y_old f ( x_old, y_old h f ( x_new, y_new h O ( h3 Actually, the backward and trapezoidal stencils are only implicit for general f. If we specialize to a particular form of f as follows, they can all be made explicit (notice we are now dropping the big-o terms: > f (x,y -> lambda*y; ForwardEuler isolate(convert(forwardeuler,polynom,y_new; BackwardEuler isolate(convert(backwardeuler,polynom,y_new; Trapezoidal isolate(convert(trapezoidal,polynom,y_new; f ( x, y λy ForwardEuler y_new y_old + λy_oldh BackwardEuler y_new y_old + λh y_old + λy_oldh Trapezoidal y_new λh It is convenient to turn these into mappings using unapply. For example, _ForwardEuler is now a procedure that take y_old, lambda and h and returns y_new using the ForwardEuler stencil. > _ForwardEuler unapply(rhs(forwardeuler,y_old,lambda,h; _BackwardEuler unapply(rhs(backwardeuler,y_old,lambda,h; _Trapezoidal unapply(rhs(trapezoidal,y_old,lambda,h; _ForwardEuler ( y_old, λ, h y_old + λy_oldh _BackwardEuler ( y_old, λ, h y_old + λh y_old + λy_oldh _Trapezoidal ( y_old, λ, h λh We now write a procedure that calculates an approximate solution for y(x using one of the above stencils. We calcuate values of y at N + discrete points from x 0 to x xf. The spacing between the points is h xf/n. We take for initial data y(0 y0. The procedure returns a list of N+ ordered pairs corresponding to our numerical solution for (x,y: > EULER proc(lambda,xf,y0,n,stencil local h, x, y, i: h xf/n: x Array(0..N,[seq(evalf(i*h,i0..N]: y Array(0..N: y[0] y0: for i from to N do: y[i] evalf(stencil(y[i-],lambda,h: od: [seq([x[i],y[i]],i0..n]: end proc: Here is the output using the trapezoidal stencil and ten points (lambda : > EULER(,,,0,_Trapezoidal; [ [ 0., ], [ ,. ], [ , ], [ , ], [ , ], [ , ], [ , ], [ , ], [ , ], [ , ], [., ] ] Here is a plot of the numeric solution obtained from the three methods versus the exact solution y exp(lambda*x [in cyan]. Experiment with different values of N and lambda and you will see that trapezoidal method [blue] generally does better than the other two [green and blue]. > N 5; lambda /; plot([euler(lambda,5,,n,_forwardeuler,euler(lambda,5,,n,_backwardeuler,euler(lambda,5,,n,_trapezoidal,exp(lambda*x],x0..5,color[red,green,blue,cyan];

4 N 5 λ The procedure EULER_ERROR calculate the discrepancy between the numerical and analytical expressions for y at x xf for the various stencils. > EULER_ERROR proc(lambda,xf,y0,n,stencil: evalf(abs(euler(lambda,xf,y0,n,stencil[n+][]-exp(lambda*xf: end proc: > EULER_ERROR(/,0,,000,_BackwardEuler; It is interesting to plot the log(error versus log(n for the schemes: > lambda -: N_low 0: N_high 400: xf 0: forward_error evalf([seq([log(i,log(euler_error(lambda,xf,,i,_forwardeuler],in_low..n_high]: backward_error evalf([seq([log(i,log(euler_error(lambda,xf,,i,_backwardeuler],in_low..n_high]: trap_error

5 evalf([seq([log(i,log(euler_error(lambda,xf,,i,_trapezoidal],in_low..n_high]: plot([forward_error,backward_error,trap_error],color[red,green,blue],axesboxed; In the log-log plot, the error in the forward an backward schemes asymptote to a line of slope - for large N, while the error curve for the trapezoidal algorithm goes to a line of slope -. This means that the error in y(xf for the first two schemes goes like N^- while it goes like N^- for the trapezoidal scheme. Since N ~ /h, this gives errors of O(h and O(h^ for the forward/backward and trapezoidal scheme, respectively. Hence, if the error in one step of a numerical scheme is O(h^(p+, then one can expect the global error in the simulation to be O(h^p. By "global error" I mean the error in the value of y(xf obtained from y(0 by taking many small steps (roughly speaking.

FINITE DIFFERENCES. Lecture 1: (a) Operators (b) Forward Differences and their calculations. (c) Backward Differences and their calculations.

FINITE DIFFERENCES. Lecture 1: (a) Operators (b) Forward Differences and their calculations. (c) Backward Differences and their calculations. FINITE DIFFERENCES Lecture 1: (a) Operators (b) Forward Differences and their calculations. (c) Backward Differences and their calculations. 1. Introduction When a function is known explicitly, it is easy