Alejandro Garcia - Numerical Methods for Physics 2ed

(1)

FOR PHYSICS

(2)

Se c o n d Ed i t i o n

Numerical Methods for Physics

Alejandro L. Garcia

San Jose State University

(3)

Chapter 1 Preliminaries

This chapter has no physics; to use the computer to do physics, one must first know how to use it to do math. The book presents algorithms in their general form, but when we sit down at the computer we have 10 give it instructions that it understands. Sections 1.2 and 1.3 present a synopsis of the MATLAB and C + + programming languages, and some simple programs are developed in Section 1.4. The chapter concludes with a discussion of the effect of hardware limitations (e.g., round-off errors) on mathematical calculations.

1.1 PROGRAMMING

General Thoughts

Before we get started, let me warn you th at this book does not teach pro gramming. Presumably, you have already learned a programming language (it doesn’t really m atter which one) and have had some practice in writing pro grams. This book covers numerical algorithms, specifically those th at are most useful in physics. The style of presentation is informal. Instead of rigorously deriving all the details of all possible algorithms, Til cover only the essential points and stress the practical methods.

If you’ve had a m ath course in numerical analysis, you may see some old friends (such as Romberg integration). This book emphasizes the application of such methods to physics problems. You will also learn some specialized techniques generally not presented in a mathematics course. If you have not had numerical analysis, don’t worry. The book is organized assuming no prior knowledge of numerical methods.

In your earlier programming course I hope you learned about good program ming style. I try to use what I consider good style in the programs, but everyone has personal preferences. The point of good style is to make your life easier by organizing and structuring your program development. Many programs in this book sacrifice efficiency for the sake of clarity. After you understand how a

(6)

2 CH APTER 1. PRELlMJ.NA.if MS

program works, you should make it a regular exercise to improve it. However, always be sure to check your improved version with the original.

Most of the exercises in this book involve programming projects. In the first few chapters, many exercises require only that you modify an existing program. In the later chapters you are asked to write more and more of your own code. The exercises are purposely organized in this fashion to allow you to come up to speed on whatever computer system you choose to use. Unfortunately, computational physics is often like experimental work in the following regard: Debugging and testing is a, slow, tedious, but necessary task similar to aligning optics or fixing vacuum leaks.

Program m ing Languages

In writing this book, one of the most difficult decisions I had to make was choos ing a language. The obvious choices were Basic, FORTRAN, MATLAB, C + + , and Java. I also considered symbolic manipulators such as Maple and Math- ematica. When the first edition of this book appeared, there were significant differences among these choices. Some were more powerful, but difficult to use; others had better graphics, but were not portable across computing platforms, etc. Since that time, advances in software engineering have diminished the de ficiencies (and in many ways the distinctiveness) of these languages, making the choice of language for the second edition even more difficult. With my edi tor’s assistance, we put the question to students and instructors using the first edition, and their choices were MATLAB and C++.*

MATLAB is the language that I encourage my students to use in their coursc work. Although you may not be familiar with MATLAB, it is widely used in both academia and industry. It is especially popular in the engineering commu nity and with applied mathematicians. MATLAB is very portable; it runs 011

Windows PCs, Macintoshes, and Unix workstations.

MATLAB is an interpreted language with excellent scientific libraries. Be cause it is an interpreted language, it is easy to use interactively, while the compiled libraries improve its performance. Being an interpreted language also makes MATLAB very clean. Many details (such as dimensioning matrices) are handled automatically. MATLAB has very good graphics facilities, including high-level routines (e.g., contour and surface plots). If you are comfortable us ing Basic, FORTRAN, or symbolic manipulators, you should have no trouble programming in MATLAB.

C + + is a rich, elegant, and powerful programming language. Most of the applications on your computer were probably written in C + + . Arguably. FOR TRAN remains the dominant language in the physics community, but C + + is the lingua franca of engineering. For these reasons many students are eager to learn this object-oriented language. C + + is difficult to master, but knowing the basics will suffice for programming the algorithms in this book. If you have programming experience with C or Java, you will probably enjoy using C + + .

(7)

1.2 BASIC ELEMENTS OF MATLAB

This scction summarizes the basic elements of MATLAB. Advanced features are introduced in later chapters as we need them. The MATLAB manuals include several tutorial chapters, along with a complete reference to the language. If you doirt have a copy of the manual at hand, most of it is available from the built-in help system. For other MATLAB tutorials, see the texts by E tter [44] and by Hanselman and Littlefield [70].

Variables

The fundamental data type in MATLAB is the matrix (MATLAB is an acronym for MATrix LABoratorv). A scalar is a 1 x 1 matrix, a row vector is a 1 x iV matrix, and a column vector is an N x 1 matrix. Variables are not declared explicitly; MATLAB just dimensions them as they are used. For example, take the scalars x and y, the vectors a and b , and the matrices C . D , and E. and give them the values

x — 3; y = -2 ; a = 1 2 3 b = [ 0 3 - 4 ] ' 1 0 1 ' 0 1 1 1 x c = 0 1 - 1 ; d = 2 3 - 1 ; e = 0 - 1 1 2 0 0 0 1 X y / — l (1.1)

In MATLAB these variables would be set by the assignment statements

x = 3 ; % These a r e some sim p le a s s ig n m e n ts

y “ - 2 ; a = [1; 2; 3 ] ; yo Column v e c t o r a ; Row v e c t o r b b = [0 3 -4 ] ; C = [1 0 1; 0 1 - 1 ; 1 2 0 ] ; % M a tr ic e s D = [0 1 1; 2 3 - 1 ; 0 0 1 ] ; E = [1 p i ; 0 - 1 ; x s q r t ( - l ) ] ; % I n MATLAB, p i = 3 . 1 4 . . .

Variable names in MATLAB, as in most languages, must start with a letter but can be composed of any combination of letters, numbers, and underscores (e.g., mass, m a s s _ o f.p a rtic le . M assD fP article2). Anything following a percent sign is considered a comment in MATLAB.

The semicolon a t the end of each assignment marks the end of the statement; you can put multiple statements on a line by separating them with semicolons. If this semicolon is omitted, the statement is assumed to end at the end of the line, and the value assigned is displayed on the screen (sometimes useful but more often annoying). Notice that rows in a matrix are separated by semicolons.

Two handy MATLAB functions, for creating matrices are z e r o s and ones.

The statement A=zeros(M,N) sets A to be an M x Ar matrix, with all elements equal to zero. The ones function works in the same fashion, but creates matrices filled with ones.

(8)

( W . A / T / M /. I ' H I ' I U M I N A I U M

M athem atics

The basic arithmetic operations are defined in the natural manner. For example», the MATLAB statements

z = x - y; t = b * a ; F = C + D; G = C * E;

assign the values

V, Some b a s i c o p e r a t i o n s t = -6 ; F = ' 1 1 2 4 7T + Ì 2 4 _ 2 ; G = : - 3 — 1 — i 1 2 1 1 7T — 2 (1.2)

The power operator is ", thus 2~3 is 2:* = 8. Other mathematical functions are available from MATLAB's large collection of built-in functions (Table 1.1).

MATLAB performs matrix multiplication; thus in the example above, Gij =

CikE kj. Notice that b*a is just the dot product of these vectors. MATLAB will balk if you try to do a matrix operation when the dimensions don’t match (e.g., it will not compute C+E). For matrices, division is implemented by using Gaussian elimination (discussed in Chapter 4).

Sometimes we want to perform operations element by element, so MATLAB defines the operators .* . / and . Here are some examples of these array operations:

H = C .* D; °/0 These o p e r a t i o n s a r e p e rfo rm e d J = E . ~ x ; % e le m e n t-b y -e le m e n t

In this case H ^j = C i j D i j and J^j = (Eitj ) x , thus

(1.3)

Individual elements of a m atrix may be addressed by using their indices. For example, J ( l , 2 ) equals ?r3 and J ( 3 , l ) equals 27. Similarly, for vectors, b(3) (or b ( l ,3 )) equals - 4 . Notice th a t matrix indices start at 1 and not 0.

Matrix B is the transpose of m atrix A if Aij = B j i , that is. the rows and columns are exchanged. The Herrnitian conjugate of a matrix is the transpose of its complex conjugate. In MATLAB

‘

0 0 1 "

1 7T3

H =

0

3

1 ; J =

0 -1

0 0 0

_{1 t}

o <1

₁

__ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ K = J>; L = J . ’ % E e r m itia n c o n ju g a te °/, T ra n sp o se

give the values

1 0 27 ‘ _{T —} 1 0 27 ‘ o

7T 1 I—1 ? — 7T* — 1 —i (1.4) The Herrnitian conjugate of J is K , while L is the transpose of J.

(9)

Table 1.1: Selected MATLAB mathematical functions. a b s (x ) Absolute value or complex magnitude norm(x) Magnitude of a vector

s q r t ( x ) Square root s in ( x ) , cos(x) Sine and cosine t a n ( x ) Tangent

a ta n 2 (y ,x) Arc tangent of y /x in [0, 2tt] exp(x) Exponential

lo g (x ), loglO (x ) Natural logarithm and base-10 logarithm

rem (x,y) Remainder (modulo) function (e.g., rem( 1 0 ·3 ,4 ) =2.3) f lo o r ( x ) Round down to nearest integer (e.g., f l o o r (3 .2 ) =3) c e i l ( x ) Round up to nearest integer (e.g., c e il(3 .2 ) = 4 ) rand(N) Uniformly distributed random numbers from

the interval 0, 1). Returns N x N matrix. randn(N) Normal (Gaussian) distributed random numbers

(zero mean, unit variance). Returns N x N matrix.

Loops and Conditionals

Repeated operations are performed by using loops. Here is an example of a f o r loop in MATLAB:

f o r i = l : 5 % Your b a s ic lo o p ; i goes from 1 to 5 p ( i ) = i~2;

end % This is th e end of th e loop

This loop assigns the value p = [ 1 4 9 16 25]. The body of the fox loop (i.e., the set of statements executed in the loop) is terminated by the end statement. Notice th at p is created as a row vector. If we wanted it to be a column vector, we could build it as

f o r i * l : 5 % Your b a s ic loop; i goes from 1 t o 5

p ( i , l ) = i" 2 ; °/e p i s a column v e c to r

end % T his i s th e end of th e loop

or

f o r i - l : 5 % Your b a s ic lo o p ; i goes from 1 t o 5 p ( i ) = i~2;

end c/. This i s th e end of th e loop p = p . ’ ; % Transpose p in to a column v e c to r

using the transpose operator.

In a f o r loop, the default step is +1. but it is possible to use a different increment. For example, the loop

(10)

< W : \ r m t f. I ’HM.IMtNAHIHS

f o r i = 1:2:5 X Loop over odd v a lu e s of i q ( i ) = i ;

q ( i+ l) = - i ; end

assigns the values q = [ 1 - 1 3 - 3 5 - 5 ] .

MATLAB also has w hile loops; here is a simple example: w h ile ( x > 1 )

x = x /2 ; end

A w hile command executes the statements in the body of the loop while the loop condition is true. If x — 5 before the loop, then x will equal | when the loop completes. The b reak statement can he used to terminate f o r loop« or w hile loops.

Here are some examples of how conditionals arc implemented; you see that it is quite standard.

i f ( x > 5 ) z = z - l ; y = MaxHeight; end

i f ( x >= x^min & x <= x_max s t a t u s = 1; e ls e s t a t u s = 0; end i f ( x == 0 I x == 1) X Another c o n d itio n a l u s in g e l s e i f f la g = 1;

e l s e i f ( x < 0 ft x -1 ) X N otice t h a t e l s e i f i s ONE WORD f l a g = - 1 ;

e ls e

f la g = 0; end

Notice that equals and not equals are == and ~=. respectively. Logical “and” is & (ampersand), and logical “ox” is I (vertical bar). The end command terminates both loops and conditionals.

Colon Operator

The colon operator, : , is one of MATLABJs handiest, tools.* Let’s consider a few examples of its use. First, the for loop,

* F O R T R A N 90 has a similar colon operator

) % A more com plicated c o n d itio n a l X T his c o n d itio n a l u s e s e ls e

A A s im p le c o n d i t i o n a l

(11)

t a u = 0 .1 ; f o r 1=1:100

t i m e ( i ) = t a u * i ; end

could be replaced with

t a u = 0 .1 ;

i=l:100;

t ime = t a u * i ;

In the latter, a vector i = [ i 2 . . . 100] is created. We may further abbreviate this to

t a u = 0 .1 ;

tim e = t a u * (1 :1 0 0 ) ;

In all three cases, the vector tim e= [0 .1 0 .2 . . . 10 .0 ] is created.

The colon operator is also useful for looping over rows or columns of a matrix. For example, the loop

[M,N3 = s i z e ( A ) ; */, F in d d im e n sio n s of A f o r i “ l:M

f i r s t ( i ) = A ( i , l ) ; l a s t ( i ) = A ( i , N ) ; end

copies the first and last columns of matrix A into the vectors f i r s t and l a s t .

The above can he replaced with

[M,N] = s i z e ( A ) ; % F in d d im en sio n s o f A f i r s t = A ( : , 1 ) ;

l a s t - A (: , N ) ;

Not only does using the colon operator abbreviate our code, but it also makes it run faster. The program becomes more efficient because we are explicitly executing a vector operation instead of performing an element-by-element cal culation.

Input, O utput, and Graphics

MATLAB has various types of input and output facilities. The in p u t command prints a prompt to the screen and accepts input from the keyboard. Here is a simple example of its use:

x = i n p u t ( 'E n t e r th e v a lu e o f x : >);

In this example, you can enter a scalar, a matrix, or any valid MATLAB ex pression.

The d i s p command may be used to display the value of a variable or to print a string of text:

(12)

8 C l / A l ' r m I. r iW U M IN A H /K S

Tabic 1.2: Selected MATLAB graphics functions. p l o t( x ,y ) Plot vector y versus vector x lo g lo g ( x ,y ), s e m ilo g x (x ,y ), Plot vector y versus vector x sem ilo g y (x ,y ) using log or semilog scales p o l a r (t h e t a , rho) Polar plot.

c o n to u r(z ) Contour piot of matrix z mesh(z) 3-D wire-mesh plot of matrix z t i t l e ( ’t e x t O? Write a title oil a plot

x la b e l( ’t e x t 3) , y l a b e l ( ’t e x t ’) Write axis labels on a plot p r i n t Print graphics

M = [1, 2 y 3; 4 , 5, 6; 7 , 8 , 9 ];

d i s p ( 'T h e v a lu e o f M i s ; ) ;

d isp (M ); produces the output.

The v a lu e o f M i s

1 2 3

4 5 6 7 8 9

Formatted output is also available with the f p r i n t f command,

f p r i n t f ( ’The v a lu e s of x and y a r e %g and %g m e te rs \ n ’ , x ,y )

The values of the variables x and y arc displayed in place of the Jig’s. The \n at the end of the text string indicates a carriage return (new line). The MATLAB commands lo ad and save can be used to read and write data files.

MATLAB has various graphics commands for creating x y plots, contour plots, and three-dimensional wi re-mesh plots. Table 1.2 gives a list of a few of the basic graphics commands.

MATLAB Session

When you first enter the MATLAB environment., you are at the command level as indicated by the >> prompt (in the regular edition) or the EDU» prompt (in the student edition). From the command line you can enter individual MATLA B commands. To end your MATLAB session, type q u it or e x i t .

For programming, it is more convenient to enter a set of commands to be executed in a file. In the MATLAB terminology such a script of commands is called an M-file. Our programs and functions will all be M-files. You run an M-file by invoking its name (the name of the file) on the command line. Before running a program you need to tell MATLAB where to look for your M-files.

(13)

a) 1 o.sj 0.6 - 0.4 " 0.2 0 -0.2 -0.40 f(x) = exp(-x/4)*sin(x) 20 10 510 f<x> = exp(-x)*sin(x)" <*) 10 15 1 0, 0.6 k °'4 ,’' \ \exp'-x/4) ^ °'2f oi -0.2= 0. f(x) = exp{-x/4)*sir»(x) oJ— - b) ° 5 x0 15 20 90 1 d)

Figure 1.1: Samples of MATLAB plotting.

th at is, the directory where your files are located. MATLAB searches for M-files in all locations specified in a list called the “path.” Use the p a th command or the “Set path...” menu item to add your directories to MATLAB’s path.

After MATLAB executes the commands in the M-file, it returns control to the command line. You can then enter individual commands (for example, to display the values of your variables). The interactive help may be used from the command line. For example.

EDU» h e lp b e s s e l

tells you about MATLAB’s Bessel function routines. You can also get help on special characters (e.g.. try h e lp &).

EXERCISES

(R eco m m en d ed exercises in d icated b y boldface n u m b ers)

1. For the matrix A = [ l 2; 3 4], use compute MATLAB to find: (a) A*A; (b) A . * A ; (c) A - 2; (d) A.*2; (e) A /A ; (f) A . / A . [MATLAB]

2. Given the vectors x = [1 2 3 . .. 10] and y = [1 4 9 . . . 100], plot them in MATLAB using: (a) p lo t (x,y); (b) p lo t (x,y , * + *); (c) p l o t ( x ,y , ,x,y , 3 + >); (d) p lo t (x ,y, *-* > x ( l : 2 : 10) , y ( l:2 :1 0 ) , * + ’); (e) semilogy(x,y); (f) loglogCx.y, ’ + ’) [MATLAB]

3. Reproduce the plots shown in Figure 1.1. Try to be as accurate as possible in your reconstruction. [MATLAB]

(14)

c i i A r m i i. i'i u u j m h w u i k s

Table 1.3: Selected C + + mathematical functions. ____ pow(x,y) Raising to a power, x y

fa b s (x ) Absolute value s q r t( x ) Square root s i n ( x ) , cos(x) Sine and cosine ta n (x ) Tangent

a ta n 2 (y ,x ) Arc tangent of y /x in [0,27r] exp(x) Exponential

l o g ( x ) . loglO (x) Natural logarithm and base-10 logarithm

f lo o r ( x ) Round down to nearest integer (e.g., f l o o r (3 .2 ) =3) c e i l ( x ) Round up to nearest integer (e.g.. c e i l (3 .2 ) =4) fm od(x,y) Remainder of x /y (e.g.. fm o d (7 .3 ,2 .0 )= 1 .3 )

double x = 4, y = 2 .5 , z ; z = (3*x - y + 0 . 5 ) / 2 .0 ;

assigns the value z=5. There is no built-in arithmetic operator to raise a value to a power; use the pow(x,y) function (e.g., pow (2.0 ,3 .0 ) is 23 = 8). The modulo operator is % so 23°/04 equals 3 since ^ — T>f.

C-\—h provides several shortcuts for common arithmetic operations. The

most common is i++ for i= i+ l (similarly, i — for i = i - l ) . Other shortcuts are x += 2 .5 ; / / Same as x = x + 2 .5 ;

y -= 3; / / Same as y = y - 3; z *= x; / / Same as z = z * x; y / » x + z ; / / Same as y = y / ( x + z ) ;

Commonly used mathematical functions are available in the standard library <math.h>. Table 1.3 gives a short list of some of the basic functions.

Loops and Conditionals

Repeated operations are performed by using loops. Here is an example of a f o r loop in C + + :

i n t i ; double p [ 5 + l ] ;

f o r ( i = l ; i<=5; i++ ) / / A b a s ic lo o p ; i goes from 1 to 5 pCi] = i * i ;

This loop assigns the values 1, 4, . . . , 25 to p [ l ] , p [2]. . . . ? p [5]. The body of this f o r loop only contains one statement. Braces. {}, are needed if the body contains multiple statements; for example,

i n t i ; double x = 1 .0 , y = - 1 .0 ; f o r ( i = l ; i<=5; i++ ) {

(15)

x *= i ;

y /= x;

>

By convention, the statements within a loop are indented to outline the loop’s structure.

C + + also has w h ile loops. Here is a simple example: double x = 5;

w h ile ( x > 1 ) x /= 2;

The statements in the body of the loop are repeatedly executed while the loop condition is true. In this example x will equal | when the loop completes. The break statement can be used to terminate f o r loops or w h ile loops.

Here are some examples of how conditionals are implemented: First, a simple i f statement

i f ( x > 5 ) { / / A sim ple c o n d itio n a l

z — ;

y = MaxHeight; >

Second, an i f - e l s e conditional

i f ( x >= x_min && x <= x_max ) s t a t u s = 1;

e l s e

s t a t u s = 0;

Logical “and” is && (two ampersands) and logical “or” is I I (two vertical bars). This conditional can be written as

s t a t u s = (x >= x j n i n && x <= xjmax) ? 1 : 0 ;

Third, a conditional using e ls e i f

i f ( x == 0 | | x == 1) / / I f x e q u a ls 0 o r 1 f l a g = 1; e ls e i f ( x < 0 && x != -1) f la g = -1; e ls e f l a g = 0;

Logical “equals” and “not equals” are — and ! =, respectively.

Input and Output

The introduction of “streams” in C + + is a great improvement over the input and output routines originally available in C. For example, the lines

(16)

double x = 3 .1 ;

cout << " Value of x i s " << x << " m e te rs'1 << en d l; display

Value of x i s 3.1 m eters

to standard output, (which is normally your screen). The e n d l stream manipu lator indicates an end-of-line (i.e., a new line).

Similarly, the input stream c in allows us to enter d ata from the keyboard. The lines double y; cout « "E n te r v a lu e of y: M; c in » y; display E n te r v a lu e of y: _

to the screen with the cursor (_) waiting for you to enter the value of y. Streams can also bo used to read and write files.

EXERCISES

6. Find the errors in each sot of C ++ statements below: / / (a)

---const double pi = 3.141592654 double radius, cixcum - 2*pi*radius;

// (b) --- ---int i; double x=l;

for( i=l, i<10, i-H- ) x « x+i; \ \ Increment x

// (c) ---int new=l; a=l; b=2;

if( new > 5 ) a -= new; new - a; else b += new; new = b; // (d) -- ----double y = l, y_max=50*50; w hile( 0 < y <= y_max ) y *= 2;

You can either check these by hand or have the computer help you find the er rors. [CH—I-]

(17)

7. For each set of C + + statements below, find the value of x after the code executes: int i, j; double x, y; // Ca) ---i—3; j=4; X = (i/j)*(j/i); // Cb) ---x=l; fo r ( i= l; i<10; i+=2 ) x /= i ; // Cc) --- ---x=l;

forC i= l; i<=10; i++ ) i f ( i > 6 ) x i ; e lse i f ( i > 3 ) x = 2*i; e ls e x—; // (d> ---x=-L; y=l; w hile( x < y ) x » ( x*y < 0 ) ? -x : y++;

You can either work these out by hand or on the computer. [C++]

8. For each set of C + + statements below, find the value of x after the code executes. Warning: Results may not be what you expect.

i n t i , j ; double x,y; // (a) ---x=l; fo r ( i » l ; i<5; i++ ) x = i+x / 2.0; / / (b) ---x=l; f o r ( i= l; i<10; i+=2 ); x /= i; / / <c) ---i=u fo r ( i= l; i<=10; i++ ) i f ( i > 5 ) x -= i ; e lse j = 2*i; x = j/2 ; // (d) ---x = 1; y = 2; fo r ( i * i ; i<*5; i++ ) y *= x; x *= y;

I recommend that you work these out by hand before checking them on the com puter. [C++]

(18)

(U W T K /f L I'UFJJMIN \un:s

Table 1.4: Outline of program o rthog, which evaluates (hr dot product, of a pair of three dimensional vectors.

• Initialize the vectors a and b .

• Evaluate the dot product as a b = a-ibi 4- b 2 -1- a ^ b j.

• Print dot product and state whether vectors arc orthogonal.

See pages 31 and 32 for program listings.

1.4 PROGRAMS AND FUNCTIONS

Orthogonality Program in M ATLAB

In this section we write some simple programs using MATLAB and C+-K Our first example, called orthog. tests whether two vectors arc orthogonal by com puting their dot product. This simple program is outlined in Table 1.4.

We first consider the MATLAB version, listed oil page 31. In MATLAB, a

program's name is set by the program’s file name. In this case, the program is in a file called orthog.m . The first few lines of o rth o g are

7t o r th o g - Program t o t e s t i f a p a i r o f v e c t o r s

I i s o r t h o g o n a l . Assumes v e c t o r s a r e i n 3D sp a c e

c l e a r a l l ; h e lp o r th o g ; C le a r t h e memory and p r i n t h e a d e r

The first two lines are comments; if you type h e lp o rth o g from the command line, MATLAB displays: these lines. The c le a r a l l command on the third line clears the memory. The h e lp statement on this line serves to display the first two lines each time you run o rth o g .

The next few lines of o rth o g are

%* I n i t i a l i z e t h e v e c t o r s a and b a = i n p u t ( ’E n te r th e f i r s t v e c t o r : ’ ) ; b = i n p u t ( ’E n te r t h e second v e c t o r : ; ) ;

The vectors are entered using the in p u t command on these lines. The comments that begin with %* are those that have corresponding entries in the program’s outline (see Table 1.4).

The next few lines calculate the dot product.

%* E v a lu a te t h e d o t p r o d u c t a s sum ov er p r o d u c ts of e le m e n ts a_ d o t_ b = 0;

f o r i = l : 3

a _ d o t_ b - a_ d o t_ b + a ( i ) * b ( i ) ; end

(19)

The f o r loop, using index i, goes over the components of the vectors. A slicker way to do the same thing would be to use

E v a lu a te t h e d o t p ro d u c t a s sum o v er p r o d u c ts of e le m e n ts a _ d o t_ b * a * b ' ;

In this case, we use MATLAB’s matrix multiplication to compute the dot prod uct as the vector product, of the row vector a and column vector b ; (using the Hermitian conjugate operator ’).

The last lines of o r t h o g are

P r i n t d o t p ro d u c t and s t a t e w h eth er v e c t o r s a r e o r th o g o n a l i f ( a _ d o t_ b == 0 ) d i s p ( ’ V e c to rs a r e o r t h o g o n a l ’) ; e l s e d i s p ( ’V e c to rs a r e NOT o r t h o g o n a l ') ; f p r i n t f ( ’Dot p ro d u c t = 7«g \n* ,a _ d o t_ b ) ; end

According to the value of a_dot_b, the program displays one of the two possible responses.

Here is the output from a typical run:

» o r t h o g o rth o g - Program t o t e s t i f a p a i r o f v e c t o r s i s o r th o g o n a l. Assumes v e c t o r s a r e i n 3D sp a c e E n te r t h e f i r s t v e c t o r : [ 1 1 1 ] E n te r t h e sec o n d v e c t o r : [1 - 2 1] V e c to rs a r e o rth o g o n a l

If. instead, you get the following error message,

? ? ? U ndefined f u n c t i o n o r v a r i a b l e *o r t h o g 5 ,

then your MATLAB path probably does not point to the directory containing orthog.m .

O rthogonality Program in C + +

Now we consider the C + + version of the o rth o g program, which tests if a pair of vectors are orthogonal by computing their dot product. The program is outlined in Table 1.4 and listed on page 32.

The first few lines are

/ / o r th o g - Program t o t e s t i f a p a i r o f v e c t o r s / / i s o r th o g o n a l. Assumes v e c t o r s a r e i n 3D sp ace # in c lu d e < io s tre a m .h >

(20)

.18 ('U M 'T E H I. r i l t t U M I N A U ms

The first two lines are comments reminding us what the program does. The third line serves to include the io stre a m library, which allows us to use input and output streams. The next line marks the beginning of the main program

v o id m a in () {

with a matching } at the end of the program. The first lines in the body of the program are

/ / * I n i t i a l i z e t h e v e c t o r s a and h d o u b le a [ 3 + l ] , b [ 3 + l ] ; c o u t « " E n te r t h e f i r s t v e c t o r ” « e n d l; i n t i ; f o r ( i = l ; i< = 3; i++ ) { c o u t « " a [ M « i « "] = c in » a [ i ] ; >

Comments marked as / / * correspond to entries in the program’s outline (see Tabic 1.4). Vectors a and b are declared as floating-point arrays with four elements, three components plus one unused element (index zero). The output statements (cout « . . . ) display the following prompt to the screen:

E n te r t h e f i r s t v e c t o r a [ l ] = _

The input statement (c in » a [ i ] ;) reads the value you enter at the keyboard into a [ i] . The next few lines

c o u t « " E n te r th e second v e c t o r ” << e n d l; f o r ( i = l ; i<=3; i++ ) f

c o u t « " b [" « i « M] = c in >> b [ i ] ;

>

read in vector b in a similar fashion.

Next, the program evaluates the dot product, using

/ / * E v a lu a te t h e d o t p ro d u c t a s sum o v e r p r o d u c ts o f e le m e n ts d o u b le a _ d o t^ b = 0 .0 ;

f o r ( i = l ; i<=3; i++ ) a_ d o t_ b += a [ i ] * b [ i ] ;

This f o r loop contains only one statement so braces are not needed. Finally, the lines

/ / * P r i n t d o t p ro d u c t and s t a t e w h e th e r v e c t o r s a r e o rth o g o n a l i f ( a_ d o t_ b == 0 .0 )

c o u t « " V e c to rs a r e o r t h o g o n a l11 << e n d l; e l s e {

(21)

Table 1.5: Outline of program in te r p , which interpolates and extrapolates data.

Initialize the data points, (rci,yi), (^2,2/2^ &nd (^3,^3) to be fit by a

quadratic.

Establish the range of interpolation (from xmin to ormax).

Find y* for the desired interpolation values of x*, using the function i n t r p f .

Plot the curve given by (z*,2/*)> and mark the orginal data points.

c o u t << " V e c to rs a r e NOT o r t h o g o n a l” « e n d l; coTit « "Dot p ro d u c t - H « a„ d o t_ b « e n d l;

}

display the result.

Here is the output from a typical run:

E n te r t h e f i r s t v e c t o r a [ l ] = 1 a [2] = 1 a [3 ] = 1 E n te r t h e second v e c t o r b [ l ] « 1 b [2 ] = -2 b [3 ] = 1 V e c to rs a r e o r th o g o n a l

Although this program may seem excessively simple, it should help you learn to compile, link, and run programs on your system.

Interpolation Program in M ATLAB

It is well known th at given three (z,y) pairs, one may find a quadratic th at fits the desired points. There are various ways to find this polynomial and various ways to write it. The Lagrange form of the polynomial is

oirl = (z?—ars) (u:— , (iT-siHs-xa)

' { x i —&2) (tfJL—^ 3 ! " (X‘J —& l ) ( X 2 —X 3 ) " (1 C\

(iC3-^l)(®3—a?2)

where (# i,y i), (2:2 >2/2) 5 (#3; 2/3) are the three data points to be fit. Commonly,

(22)

20 c i t A n m i. r a u u M / N A M M

Table 1.6: Outline of function i n t r p f . which evaluates the Lagrange quadratic (1.5).

• Inputs: x = [x1 #3], y = [y± y-2 and x*

• Outputs: y"

• Calculate y* = p(x*) using the Lagrange polynomial (1.5).

A simple interpolation program, called i n t e r p , is outlined in Table 1.5. The MATLAB listing is on page 31; the first few lines are

70 i n t e r p - Program t o i n t e r p o l a t e d a t a u s i n g Lagrange I p o ly n o m ia l t o f i t q u a d r a t i c t o t h r e e d a t a p o i n t s c l e a r a l l ; h e l p i n t e r p ; % C le a r memory and p r i n t h e a d e r 4/o* I n i t i a l i z e t h e d a t a p o i n t s t o be f i t by q u a d r a t i c d i s p ( ’E n te r d a t a p o i n t s as x ,y p a i r s ( e . g . , [1 2 ] ) ’) ; f o r i = l : 3 temp = i n p u t ( ’E n te r d a t a p o i n t : ’ ) j x ( i ) = t e m p ( l ) ; y ( i ) = tem p (2 ) ; end

#/o * E s t a b l i s h t h e ra n g e o f i n t e r p o l a t i o n (from x_min t o x jn a x ) x r = i n p u t ( ’E n te r ra n g e o f x v a lu e s a s [x_min x_max] : });

Here the program reads in the three (x,y) pairs and the range of values for which the data is to be interpolated.

The interpolated value y* = p(x*) is computed by the function i n t r p f from

x* — #frii„ to x* = :rmax. These values of y* (y i) are computed in the loop

%* F in d y i f o r t h e d e s i r e d i n t e r p o l a t i o n v a lu e s x i u s i n g

% t h e f u n c t i o n i n t r p f

n p l o t = 100; */0 Number o f p o i n t s f o r i n t e r p o l a t i o n c u rv e f o r i = l : n p l o t

x i ( i ) = x r (1) + ( x r (2) - x r ( l ) ) * ( i - l ) / ( n p l o t - l ) ;

yi(i) = intrpf(xi(i),x,y); % Use intrpf function to interpolate

end

Finally, the results are graphed using MATLAB’s plotting routines.

%* Plot the curve given by (xi,yi) and mark original data points p l o t ( x , y , > * ’ ,xi,yi,

x l a b e l O x 5) ; y l a b e l ( ;y 3) ;

(23)

Three point interpolation

Figure 1.2: Graphical output from the i n t e r p program. Input data is ( - 1 , 1), ( | , | ) , and (2, 4); interpolation range is from —3 to 3.

t i t l e ( ’T hree p o i n t i n t e r p o l a t i o n ’ ) ; le g e n d ( ’D ata p o i n t s ’ , ’ I n t e r p o l a t i o n ’ ) ;

The interpolation points are plotted as a solid line along with the original data points (x>y) marked by asterisks (sec Figure 1.2).

The real work is done by the function i n t r p f (Table 1.6). Functions in MATLAB are implemented as in most languages, except each function must be in a separate file. The file name must match the function name (function i n t r p f is in the file i n t r p f .m). The first lines of i n t r p f are

f u n c ti o n y i = i n t r p f ( x i , x , y )

X F u n c tio n t o i n t e r p o l a t e betw een d a t a p o i n t s X u s in g L agrange p o ly n o m ia l ( q u a d r a ti c )

X In p u ts

X x V e cto r o f x c o o r d in a t e s o f d a t a p o i n t s (3 v a lu e s ) X y V e c to r o f y c o o r d in a t e s of d a t a p o i n t s (3 v a lu e s ) X x i The x v a lu e where i n t e r p o l a t i o n i s com puted

X O utput

X y i The i n t e r p o l a t i o n p o ly n o m ia l e v a l u a t e d a t x i

The i n t r p f function has three input arguments and one output argument. How ever, a MATLAB function can have a list of output arguments. In Section 3.3 we use an adaptive Runge-Kutta routine th at has the calling sequence

f u n c t i o n [x S m all, t , t a u ] = r k a ( x , t , t a u , e r r , d e r i v s R K , p a r a m )

(24)

The i n t r p f function is slniiglilibrward, since il. just ovalunf.<*> Kqualum (1.5). The body of the function is

7e* C a lc u la te y i = p ( x i) u sin g Lagrange polynom ial

y i = ( x i - x ( 2 ) ) * ( x i - x ( 3 ) ) / ( ( x ( l ) - x ( 2 ) ) * ( x ( l ) - x ( 3 ) ) ) * y ( l ) . . .

+ ( x i - x ( l ) ) * ( x i - x ( 3 ) ) / ( ( x ( 2 ) - x ( l ) ) * ( x ( 2 ) - x ( 3 ) ) ) * y ( 2 ) . . . + ( x i - x ( l ) ) * ( x i - x ( 2 ) ) / ( ( x ( 3 ) - x ( l ) ) * ( x ( 3 ) - x ( 2 ) ) ) * y ( 3 ) ; r e t u r n ;

The ellipsis^ ( ...) ending the first two lines signals that they are continued on. the next line.

As in most languages, variables in a function are local to that function. For example, if we were to modify the value of x i inside the function i n t r p f . the variable x i in the main program (in te rp ) would be unaffected. Variables in the calling sequence are passed by value (as in C + + ) and not by reference (as in FORTRAN).

Interpolation Program in CH-+

The C + + version of in te r p , the Lagrange polynomial interpolation program, is outlined in Table 1.5 (see page 33 for the listing). The first few lines of the program are

/ / i n t e r p - Program t o i n te r p o la t e d a ta u sin g Lagrange / / polynom ial to f i t q u a d ra tic to th r e e d a ta p o in ts # in c lu d e "NumMeth.hM

double i n t r p f ( double x i , double x [ ] , double y [ ] ) ; void m ain() {

The include statement refers to the header file NumMeth. h, which lists the various libraries that wTe normally want to include (< iostream . h>. <math .h>, etc.). The declaration double i n t r p f ( ... states th at the program intends to call the function i n t r p f , which has three inputs (of type double) and which returns a value of type double.

The next, few lines of the program are

/ / * I n i t i a l i z e th e d a ta p o in ts to be f i t by q u a d ra tic d o u b le x [ 3 + l ] , y [3+ 1]; cout « "E n te r d a ta p o i n t s : “ « e n d l; i n t i ; f o r ( i = l ; i<=3; i++ ) { cout « "x[" « i « '■] = "; c in » x [ i ] ; cout << My [" << i << "] = "; c in » y [ i] ;

§ Ail ellipsis ' . . . ) is the punctuation mark that indicates &n incomplete thought. Ατι ellipse is a geometric object whose name indicates that it is an imperfect, circle.

(25)

>

/ / * E s t a b l i s h t h e ra n g e o f i n t e r p o l a t i o n (from x_min t o x_max) d o u b le x_min, x_max;

c o u t « " E n te r minimum v a lu e of x: c in » x_min; c o u t « " E n te r maximum v a lu e of x: c in » x.m ax;

The program prompts you to enter the d ata points to be fit by the Lagrange polynomial (1.5) and the range of interpolation values.

Next, the arrays x i and y i are declared by

/ / * F in d y i f o r t h e d e s i r e d i n t e r p o l a t i o n v a l u e s x i u s in g / / t h e f u n c t i o n i n t r p f i n t n p l o t = 100; / / Number o f p o i n t s f o r i n t e r p o l a t i o n c u rv e d o u b le * x i, * y i; x i = new d o u b le [ n p l o t + 1 ] ; / / A ll o c a te memory f o r t h e s e y i = new d o u b le [ n p l o t + 1 ] ; / / a r r a y s (n p lo t+ 1 e le m e n ts )

These lines could be replaced by

c o n st i n t n p l o t = 100; / / Number o f p o i n t s f o r i n t e r p o l a t i o n , c u rv e d o u b le x i [ n p l o t + 1 ] , y i [ n p l o t + 1 ] ;

since n p lo t is a constant in this program, but you should get accustomed to using new for allocating arrays.

The interpolation values of x i and y i are computed by the loop

f o r ( i = l ; i < = n p lo t; i++ ) {

x i [ i ] = x_min + ( x _ m a x - x _ m in ) * ( i - l ) / ( n p l o t - 1 );

y i [ i ] = i n t r p f ( x i [ i ] , x , y ) ; / / Use i n t r p f f u n c t i o n t o i n t e r p o l a t e

>

Note that x i [ l ] = x m\n> x i [n p lo t] = xmax, with linearly spaced values in be tween. The values of y i (y* = p(x*)) are computed by evaluating Equation (1.5). which is done by the i n t r p f function.

The program outputs the results, using

//* Print out the plotting variables: x, y, xi, yi ofstream xQut ("x.txt1’) > y 0 u t ( uy . t x t 1'), xi G u t ( Hx i . t x t " ) ,

yiOutC'yi.txt1'); for( i=l; i<=3; i++ ) {

xQut « x[i] « endl; yOut « y[i] « endl;

}

f o r ( i = l ; i < = n p lo t; i++ ) { xiO ut << x i [ i ] « e n d l; yiO ut « y i [ i] « e n d l ;

(26)

Four data files ( x .d a t, y . d a t , etc.) are created.

Unfortunately, C-h-h lacks a standard graphics library so we need a separate graphics application to plot this output. The following MATLAB commands

lo a d x . t x t ; lo a d y . t x t ; lo a d x i . t x t ; lo a d y i . t x t ; p l o t ( x , y , ’ *’ , x i , y i , ’- ’ ) ;

x l a b e l ( ’x ’ ) ; y l a b e l ( ’y 5) ;

t i t l e ( ’T hree p o i n t i n t e r p o l a t i o n ’) ; leg e n d ( ’D a t a points * ,’Interpolation’);

load and plot the data (see Figure 1.2). The last line of the program is

d e l e t e [] x i , y i ; / / R e le a s e memory a l l o c a t e d by "new"

This line is not absolutely necessary because the program exits right after re leasing the memory allocated to x i and y i. However, it is considered good programming style to clean up when you’re finished using an array.

The i n t r p f function, which evaluates the Lagrange polynomial, is listed on page 34, (see outline in Table 1.6), The first few lines of the function are

d o u b le i n t r p f ( d o u b le x i , d o u b le x [ ] , d o u b le y [ ] ) { / / F u n c tio n t o i n t e r p o l a t e betw een d a t a p o i n t s / / u s in g L agrange p o ly n o m ia l ( q u a d r a t i c )

/ / I n p u ts

/ / x i The x v a lu e where i n t e r p o l a t i o n i s computed / / x V e c to r of x c o o r d in a t e s o f d a t a p o i n t s (3 v a lu e s ) / / y V e c to r of y c o o r d in a t e s o f d a t a p o i n t s (3 v a lu e s ) / / O utput

/ / y i The i n t e r p o l a t i o n p o ly n o m ia l e v a l u a t e d a t x i

The first line gives the function’s calling sequence. There are three inputs: x i is a simple variable, and the other two. x and y, axe arrays. The function returns a value (yi), which has type double. Functions that do not return a value have type void; such functions are equivalent to FORTRAN subroutines.

The variable x i in i n t r p f is local to the function. That is, the function receives a copy of this variable from the main program; this is called “pass by value.” Since the function receives a copy, changing x i within i n t r p f does not affect its value in in te r p . If we wanted the function to receive the actual variable, the calling sequence would be

d o u b le i n t r p f ( d o u b led x i , d o u b le x [ ] , d o u b le y [ ] ) {

The ampersand (doubled x i) indicates that x i is “passed by reference.” Ar rays, on the other hand, are always passed by reference, since what the function receives is not a copy of the array, but rather the memory address where the array begins.

(27)

//* Calculate yi = p(xi) using Lagrange polynomial

d o u b le y i = ( x i - x [ 2 ] ) * ( x i - x [ 3 ] ) / ( ( x [ l ] - x [ 2 ] ) * ( x [ l ] - x [ 3 ] ) ) * y [1] + ( x i - x [1 ]) * ( x i - x [3] ) / ( (x[2] -x [ i] ) * (x [2] -x [3] ) ) *y [2]

■*" ( x i - x [ 1] ) * ( x i - x [2] ) / ( (x [3 ] -X [1] ) * (x [3] -x [2] ) ) *y [3] ; r e t u r n ( y i ) ;

These lines evaluate the Lagrange polynomial, Equation (1.5), and return the resulting value. Notice th at this long equation is written across three lines. This is a single statement th a t ends with the semicolon.

To run the i n te r p program with the i n t r p f function, you will need to com pile each routine and link them. This procedure varies significantly from system to system (e.g., make files, workspaces), so consult your compiler’s documenta tion or local experts. Resist the tem ptation to put both routines into a single file, since th a t solution will be impractical for the programs in the later chapters.

EXERCISES

9. Kernighan and Ritchie, who created the C language, advise that, “The first program to write in any language is the same for all languages: Print the words h e llo , world. This is the basic hurdle; to leap over it you have to be able to create the program text somewhere, compile it successfully, load it, run it, and find out where your output went. With these mechanical details mastered, everything else is comparatively easy.” [80] Write, compile and run a h e llo program. [Computer] 10. It is always good to know your limits. For your computer system find: (a) the largest possible floating-point number; (b) the largest integer I such that (/ -f 1) — 1 equals I; (c) the smallest possible positive floating-point number; (d) the smallest positive floating-point number x such th at (1 + x) — I does not equals zero; (e) the largest N x N matrix allowed by memory; (f) the longest row vector allowed by memory; (g) the maximum number of array dimensions allowed; for example, a(i, j, k )

is a three-dimensional array. [Computer]

11. For your computer system, write a program to estimate the number of floating point operations (e.g., multiplications) th at can be performed in one second. In C-f-h, timing routines are available in the <time.h> library. In MATLAB, the t i c and toe commands mimic a stopwatch. [Computer]

12. Modify the orthog program so that it can handle vectors of any length. Your pro gram should detect and gracefully handle erroneous inputs such as vectors of unequal length. [Computer]

13. Modify the orthog program so that it accepts a pair of three- dimensional vectors and outputs a unit vector that is orthogonal to the input vectors. [Computer]

14. Modify orthog so that if the second vector is not orthogonal to the first, the program computes a new vector that is orthogonal to the first vector, has the same length as the second vector, and is in the same plane as the two input vectors. This orthogonalization is often used with eigenvectors and is commonly performed using the Gram-Schmidt procedure. [Computer]

15. From tables we find the following values for the zeroth-order Bessel function: Jo(0) = 1.0; Jo(O.o) = 0.9385; Jo(LO) = 0.7652. Using in trp , find the estimated

(28)

values of Ju{x) for range x = 0.3, 0.9. l.L 1.5 and 2.0. Look up Mir l.n.l>11 Uv1.<u] v;ihii*

and compare. [Computer]

16. Modify in te rp so that it can handle any number of data points by using higher-order polynomials. After testing your program, give it the following values of the Bessel function: J0(0) = 1.0; J 0(0.2) = 0.9900; Jo (0.4) = 0.9604; J0(0.6) = 0.9120; Jo(0.8) = 0.8463; Jo(1.0) = 0.7652, and repeat· the previous exercise. Do your esti mates improve? [Computer]

17. Write a function that is similar to in tr p f but that returns the estimated derivative at the interpolation point. The function will accept three (x, y) pairs, fit a quadratic to the data, then return the value of the derivative of the quadratic at the desired point. [Computer]

18. A Bezier cubic curve is defined by the parametric equations

x(t) = axt* -j- hxi2 + cxt + Xi y(t) = ciyt^ + bvt 2 + Cyt + yi

where 0 < t < 1. The Bezier control points arc given by the relations

X2 = xi + cxf 3 y<2 = yi + Cyj3

xa = + (c^ 4- bx)jZ — i/2 + (c-y 4- fyj)/3

,X4 = + cx + bz + ax j/4 = 4- by 4- av

The curve goes from (x(0),y(0)) = [xx^yi) to (,c(l)?t/(l)) = (#4,2/4) and is tangent

to the lines i */2) and Write a program to draw a Bezier

curve, given the control points (xA.yA)· Draw the curve with control points (0,0), (2,1), (-1,1), and (1,0). [Computer]

1.5 NUMERICAL ERRORS

Range Error

A computer stores individual floating-point numbers using only a small amount,

of memory. Typically, single precision ( f l o a t in C + + ) allocates 4 bytes (32 bits) for the representation of a number, while double precision (double in C + + ; MATLAB’s default precision) uses 8 bytes. A floating-point number is represented by its mantissa and exponent (for 1.60 x 10” 19, the decimal mantissa is 1.60 and the exponent is —19). The IEEE format for double precision uses 53 bits to store the mantissa (including one bit for the sign) and the remaining 11 bits for the exponent. Exactly liow a computer handles the representation is not as important as knowing the maximum range and the number of significant digits.

The maximum range is the limit 011 the magnitude of floating-point numbers

given the fixed number of bits used for the exponent. For single precision, a typical value is 2i m a* 1()±38; for double precision it is typically 2±1023 « 1q±308 Exceeding the single precision range is not difficult. Consider, for example, the evaluation of the Bohr radius in SI units.

(29)

While its value lies within the range of a single precision number, the range is exceeded in the calculation of the numerator (47reoft2 & 1-24 x 10-78 kg · C2 * m) and the denominator (m«e2 « 2.34 x ID-68 kg · C2). The best solution for dealing with this type of range difficulty is to work in a set of units natural to a problem (e.g., for atomic problems work in units of angstroms, the charge of an electron).

Sometimes range problems arise not from the choice of units but because the numbers in the problem are inherently large. Let’s consider an important example, the factorial function. Using the definition

n! = n x (n — 1) x (n — 2) x . . . 3 x 2 x 1 (1.7) it is easy to evaluate n! in C-H+ as d o u b le n F a c t o r i a l = 1; i n t i ; f o r ( i - 1 ; i < - n ; i++) n F a c t o r i a l * - i ;

given th at n has been defined.

In MATLAB, using the colon operator this calculation may be performed as

nFactorial = prod(l:n);

where p ro d (x ) is the product of the elements of vector x and l : n = [1 2 ... n ] . Unfortunately, due to range problems, we cannot compute n! for n > 170 using these direct methods of evaluating (1.7).

A common solution to working with very large numbers is to use their log arithm. For the factorial,

log(rc!) = log(n) + log(n - 1) + . .. + log(3) + log(2) + log(l) (1.8) In MATLAB, this could be evaluated as

l o g _ n F a c t o r i a l - sum( l o g ( l : n ) ) ;

where sum(x) is the sum of the elements of vector x. However, this scheme is computationally expensive if n is large. An even better approach is to combine the use of logarithms with Stirling’s formula [2]

„1 = V W e - ” ( , + ± . + ¿ 5 + . . . ) (1.9) or

log(n!) = ^ k>g(2i«r) + nlog(n) - n + log ( l + ^ + ■ · ·) i 1·10) This approximation should be used when n is large (n > 30), otherwise the factorial’s original definition is preferred.

(30)

Finally; if the value of n! needs to be printed, we can ;is express ¡1. ;is

n! = (mantissa) x 10("'xl>o,lt,,a:i ( l . i i ) where the exponent, is the integer part of log50(n!), and the mantissa is l()a where a is the fractional part of log10(nl). Recall th at the conversion between natural and basc-10 logarithms is log10(#) = log10(e) log(#).

Round-off Error

Suppose we wanted to numerically compute /'(&), the derivative of a known function f ( x ) . In calculus you learned the following formula for the derivative,

f'(x) = / ( * + h) ~ / ( * ) (1 l2)

fv

with the limit that h —> 0. W hat happens if we evaluate the right-hand side of this expression, setting h = 0? Because the computer doesn’t understand that the expression is valid only as a limit, the division by zero has several possible outcomes. The computer may assign the value. In f, which is a special floating point number reser ved for representing infinity. Since the numerator is also zero, the computer may evaluate the quotient to be undefined (Not-a-Number), NaN, another reserved value. Or the calculation might be halted with a scolding diagnostic message.

Clearly, setting h — 0 when evaluating (1.12) will not give us anything useful, but what if we set h to a very small value, say h = lO-300, using double precision? The answer will still be incorrect due to the second limitation on the representation of floating-point numbers: the finite numer of digits in the mantissa. For single precision, the number of significant- digits is typically 6 or 7 decimal digits; for double precision it is about 16 digits. Thus, in double precision, the operation 3 + 1()-20 returns an answer of 3 because of round off; using h — 10“ 300 in Equation (1.12) will almost certainly return 0 when evaluating the numerator.

Figure 1.3 illustrates the magnitude of the roundoff error in a typical cal culation of a derivative. Define the absolute error as

A(h) = / '( * ) _ l i x + - /(* )

h (1.13)

Notice that A(ft) decreases as h is made smaller, which is cxpected given Equa tion (1.12) is exact as h -+ 0. Below h = 10- 8 , the error starts increasing due to roundoff effects. At the smallest values of h (< 10_1C), the error is so large that the answer is worthless. In the next chapter we’ll return to the question of how best, to compute derivatives numerically.

To test round-off tolerance, we define eT as the smallest number th a t, when added to 1. returns a value different from 1. In MATLAB, the built-in function eps returns £r; on my computer, eps « 2.22 x 10~16. In C + + , the < flo a t.h >

(31)

10° ' 10-2 < 10-4 10"* V ° 10“15 10-10 h

Figure 1.3: Absolute error A(fe), Equation (1.13), versus ft for f ( x ) = x 2 and

'x — 1.

header defines DBLJiPSILON as er for double precision. Notice in Figure 1.3 th at A (ft) plateaus when ft < er.

Because of round-off errors, most scientific calculations use double precision. The disadvantages of double precision are th at it requires more storage and th at it is sometimes (but not always) more computationally costly. Modern computer processors are designed to work in double precision, so it can actually be slower to work in single precision. Using double precision sometimes only forestalls the difficulties of round-off. For example, a matrix inverse calculation may work fine in single precision for small matrices of 50 x 50 elements, but fail because of round-off for larger matrices. Double precision may allow us to work with matrices of 100 x 100. but if weneed to solve even larger systems we will have to use a different algorithm. The best approach is to work with algorithms th a t are robust against round-off error.

EXERCISES

19. Suppose that we take electron volts as our unit of energy, the mass of the electron as our unit of mass, and set Planck’s constant equal to unity. Convert 1 kg, 1 in, and 1 s into these units. [Pencil]

20. Suppose that we take the mean radius of Earth-Sun orbit as the unit of length, the mass of Earth as the unit of mass, and a year as the unit of time. Convert the gravitational constant, G, into these units. What is the force of attraction between Earth and the Moon in these units? Between Earth and the Sun? [Pencil]

21. The probability of flipping N coins and obtaining m “heads’5 is given by the binomial distribution to be

(32)

W h a t is m ore probable, Hipping 10 coins and g e llin g tit> litwds nr flippin g 10,000 coins and ge.ui.ng e x a c tly 5000 heads? [P ('iic.il]

22. The double factorial is defined as

ir / / a\ i 6 x 4 x 2 n even

n!! = n x (n — 2) x (n - 4 ) ... x < , .

v ' v y [ 5 x 3 x 1 n o d d

(a) Write a program that prints out n\\ by evaluating its definition using logarithms. Test your program by checking that. 1000?! « 3.99 x 101284; compute 2001!!. (b) Obtain an expression for nil in terms of n!. [Pencil] (o) Write' a program that prints out. n!! Irv evaluating it using Stirling's approximation when n > 30. Compute 10000!!, 314159!! and (6.02 x 1023)!!. [Computer]

23. Suppose that von arc standing at 40° latitude and are 2 m tall, (a) Find the velocity of your feet, v t due to the rotation of Earth. Assume that Earth i^ a perfect sphere of radius R = 6378 km and that a day is exactly 24 h long, (b) Using the result from (a), compute the centripetal acceleration at your feet as a = v*/r. (c) Repeat parts (a) and (b) for your head, and compute the difference between the acceleration at your head and feet. Show how round-off can corrupt your calculation and how to fix the problem. [Pencil]

24. (a) Write a program to reproduce Figure 1.3. Use h = 1, 10' 1. lO""2,.. .. (b) Modify your program to use h = 1, 2_\ 2"2,__ The. results are strikingly different; explain why. [Computer]

25. Write a program to find er, the smallest number that when added to 1 returns a value different, from 1. Compare your result, with either M ATLAB's built-in function eps or DBL^EPSILDN, as defined in the C + + < float.h> header. [Computer]

26. Consider the Taylor expansion for the exponential

c* = i + * + | r + i " - = ^ n0c s ( *>^)

where S(x, Ar) is the partial sum with Ar +1 terms, (a) Write a program that pLots the absolute fractional error of the snm, )£>(#. N) — ex\/ec , versus N (up to Ar = 60) for a given value of a?. Test your program for x = 10, 2, —2, and —10. From the plots, explain why this is not a good way to evaluate ex when x < 0.[49] (b) Modify your program so that it uses the identity e* = l/e ~ * = l /S ( —r, oo) to evaluate the exponential when

x is negative. Explain why this approach works better. [Computer]

BEYOND THIS CHAPTER

The Lagrange formulation for assembling an interpolating polynomial has only one advantage: It is easy to understand and remember. Algorithmically, it is not the best method for polynomial interpolation for a variety of reasons, including susceptibility to round-off error when fitting highcr-ordcr polynomials. A superior approach is to build a divided difference table and use the Newtonian formulation.[33]

The round-off error in a numerical scheme can be quantitatively estimated using backward error analysis. [133] It is possible to perform calculations of ar bitrary precision by storing numbers as rational quotients (fraction with integer

(33)

APPENDIX A: M A T L A B LISTINGS 31 numerator and denominator). While a few calculations call for such accuracy (e.g., some orbital mechanics problems), the computations can be very slow.

Finally, you’ll discover th at most of the fundamental elements of numerical analysis were introduced long before the invention of the electronic computer. This is clear from the names of the basic algorithms; the litany includes Newton,

Euler, Gauss, Jacobi, and many other famous physicists and mathematicians. For historical accounts of the development of numerical analysis, sec Golds- tine [58] and Nash [91].

A PPEN D IX A: MATLAB LISTINGS

Listing 1A.1 Program orthog. Determines if a pair of vectors is orthogonal by computing their dot product.

*/% orthog - Program to test if a pair of vectors

*/, is orthogonal. JLssumes vectors are in 3D space

clear all; help orthog; % Clear the memory and print header

*/,* Initialize the vectors a and b a * input(’Enter the first vector: ’); b « input('Enter the second vector: ’);

X* Evaluate the dot product as sum over products of elements a_dot_b = 0;

for i=l:3

a_dot_b = a_dot_b + a(i)*b(i); end

Print dot product and state whether vectors are orthogonal if( a_dot_b == 0 )

disp('Vectors are orthogonal'); else

disp('Vectors are N“0T orthogonal'); fprintfC’Dot product * Jig \n’ aa_dot_b) ; end

Listing 1A.2 Program interp. Uses the intrpf (Listing 1A.3) function to inter polate between data points.

y, interp - Program to interpolate data using Lagrange % polynomial to fit quadratic to three data points clear all; help interp; 7. Clear memory and print header ·/.* Initialize the data points to be fit by quadratic dispC'Enter data points as x,y pairs (e.g., [1 2])*); for i=l:3

temp = input('Enter data point: '); x(i) = temp(i);

y(i) * temp(2 ); end

(34)

ir = input('Enter range of x values as [x_min x_max]: '); 7,* Find yi for the desired interpolation values xi using X the function intrpf

nplot = 100; */, Number of points for interpolation curve for i=l:nplot

xi(i) = xr(1) + (xr(2)-xr(1))*(i-l)/(nplot-1);

yi(i) = intrpf (xi(i) ,x,y) ; V» Use intrpf function to interpolate end

X* Plot the curve given by (xi,yi) and mark original data points p l o t ( x , y , , x i , y i , '-');

xlabel(’x'); ylabel('y ') ;

title('Three point interpolation'); legend(’Data points','Interpolation');

Listing 1A.3 Function in tr p f . Uses a quadratic to interpolate between three data points.

function yi = intrpf (xi,x,y)

X Function to interpolate between data points 7« using Lagrange polynomial (quadratic)

X Inputs

7« x Vector of x coordinates of data points (3 values) 7« y Vector of y coordinates of data points (3 values) 7« xi The x value where interpolation is computed 7« Output

7« yi The interpolation polynomial evaluated at xi

X* Calculate yi = p(xi) using Lagrange polynomial

yi = (xi-x(2))*(xi-x(3))/((x(l)-x(2))*(x(l)-x(3)))*y(l) ... + (xi-x( 1) )*(xi-x(3))/ ( (x(2)-x(l) ) * (x(2) -x(3) ) )*y (2) ... + (xi-x(l) )*(xi-x(2))/ ((x(3)-x(l) )*(x(3)-x(2)))*y{3) ; return;

APPEN D IX B: C + + LISTINGS

Listing 1B.1 Program orthog. Determines if a pair of vectors is orthogonal by computing their dot product.

// orthog - Program to test if a pair of vectors // is orthogonal. Assumes vectors are in 3D space #include <iostream.h>

void m a i n Q {

Alejandro Garcia - Numerical Methods for Physics 2ed

FOR PHYSICS

Numerical Methods for Physics

Alejandro L. Garcia

San Jose State University

Contents

Chapter 1

Preliminaries

1.1

PROGRAMMING

General Thoughts

Program m ing Languages

1.2 BASIC ELEMENTS OF MATLAB

Variables

M athem atics

0 0 1 "

1

7T3

0

1

; J =

0 -1

0 0 0

1 t

o <1

1

Loops and Conditionals

Colon Operator

Input, O utput, and Graphics

MATLAB Session

EXERCISES

Loops and Conditionals

y /= x;

Input and Output

EXERCISES

1.4 PROGRAMS AND FUNCTIONS

Orthogonality Program in M ATLAB

O rthogonality Program in C + +

Interpolation Program in M ATLAB

Interpolation Program in CH-+

EXERCISES

1.5

NUMERICAL ERRORS

Range Error

Round-off Error

EXERCISES

BEYOND THIS CHAPTER

A PPEN D IX A: MATLAB LISTINGS

APPEN D IX B: C + + LISTINGS

_{1 t}

₁