2nd Year Computational Physics Week 1 (experienced): Series, sequences & matrices

Transcription

1 2nd Year Computational Physics Week 1 (experienced): Series, sequences & matrices 1

2 Last compiled September 28,

3 Contents 1 Introduction 5 2 Prelab Questions 6 3 Quick check of your skills Introduction to Linux Procedure Series and Sequences Procedure Special Functions and Recurrence Relations Series Representations of Bessel Functions Procedure

4 6 Matrix Arithmetic Background Index Notation Matrix Operations C Arrays and Matrices Rotation Matrices Procedure

5 1 Introduction ATTENTION! You are currently reading the notes for the EXPE- RIENCED coding stream! This means you feel you have a high enough level of coding experience to go straight into the applications your demonstrators want to teach you. You should consider carefully whether the experienced or standard stream is right for you. Changing between streams runs the risk of missing important techniques so you re encouraged to stick to one stream. Occasionally there may be sections that seem a bit basic on the coding side but we felt were important to guarantee you don t skip mathematical techniques you ll need for later examples. Good luck! 5

6 2 Prelab Questions Note: Pseudo-code is just an informal description of the commands that you would pass to the computer and is designed to help you think about how you would structure a real program. You won t be compiling this, so don t worry about using perfect syntax in the pre-labs. 1. Draw a flow chart for how you would recursively compute the factorial, n! for a given integer n. Hint: There should be a termination condition when n = Draw a flow-chart for question 3 of the procedure in section 4.1 showing how you use the Euler Method to find a series expression for π. Translate this to pseudo-code. 3. (Advanced) Ok, enough flow charts. A Fourier series decomposes an arbitrary periodic function into a infinite sum of harmonic functions. The Fourier series for the function f 6

7 can be expressed as: f(x) = a a n cos(nx) + b n sin(nx) n=1 n=1 (1) Where {a n, b n } are Fourier coefficients which can be found via standard orthogonality arguments. You are given the Fourier coefficients as N-dimensional arrays, a i = a[i], b j = b[j], Write pseudo-code for a function that computes the Fourier series, truncated at order N. Assume you can call the trigonometric functions as cos() and sin(). 4. (Advanced) Repeat the above, only now you cannot call predefined trigonometric functions and must use the Taylor series expansions for sin and cos given below, truncated at order M. You will need to make use of nested loops, or alternatively define your own func- 7

8 tions. cos(x) = sin(x) = ( 1) n x2n (2n)! ( 1) n x2n+1 (2n + 1)! n=0 n=0 (2) (3) 8

9 3 Quick check of your skills 3.1 Introduction to Linux The part 2 lab computers are running Linux operating systems. Here are the standard commands: Command Description cd Move to new directory mkdir Create new directory cp Copy file mv Move file rm Remove file ls View contents of current directory touch Create file pwd Display working directory / Location of home directory ; End of line Table 1: List of basic Linux terminal commands. 9

10 The language of choice for these labs is C. We will be using the compiler gcc. To run gcc: gcc list_of_source_files -o executable_name; 1 Question: What does -o tell the compiler to do? The first library we will use is stdio, accessed by including <stdio.h> in the relevant source files. This library contains functions which deals with data input and output, including the function printf, which takes a string of characters inside double parentheses, and prints them in the command line. Note: the newline character is given by \n. 10

11 3.2 Procedure 1. Write a simple function quadratic(a,b,c,x), which returns y(x) = ax 2 + bx + c. 2. Extend this program such that a, b, c and x are entered into the terminal by the user, and the result y(x) is returned and displayed. 3. Evaluate a simple function such as quadratic(a,b,c,x) over the range 1 x 5, with 5 equallyspaced data points. 4. Export a table of arguments and function values to an external file such as quadratic.dat. 5. Read the data from quadratic.dat and use PGPLOT to graph and print this data. (It is OK to copy the PGPLOT segment directly form the example code. Read and understand the comments in the file. Try playing around with the settings.) // Example Code for Plotting data // Author: Julia McCoey

12 //Date: 01/03/2016 // This program plots the function 'quadratic' using the plotting program PGPLOT. #include <stdlib.h> #include <stdio.h> #include <cpgplot.h> #define ARRAY_SIZE 5 // Size of the arrays // Declare functions signatures. // This provides the compiler the input parameter and return types before it actually reads the function DEFINITION defined below main. float quadratic(float a,float b,float c,float x); // This the main program int main() {

13 int plotpointcount = 5; //Number of points to plot int xmin = 0; //Minimum x value on axis int xmax = 6; //Maximum x value on axis int ymin = 0; //Minimum y value on axis int ymax = 80; //Maximum y value on axis float xvalues[array_size]; //Array containing x values float yvalues[array_size]; //Array containing y values float a = 2; //Arbitrary value a float b = 3; //Arbitrary value b float c = 5; //Arbitrary value c FILE *datafile; file // File pointer for data datafile=fopen("quadratic.dat", "r"); // Open the data file // Fill x and y arrays with data. fscanf(datafile, "%f\t%f\n", &xvalues[0], &yvalues[0]); fscanf(datafile, "%f\t%f\n", &xvalues[1],

14 &yvalues[1]); fscanf(datafile, "%f\t%f\n", &xvalues[2], &yvalues[2]); fscanf(datafile, "%f\t%f\n", &xvalues[3], &yvalues[3]); fscanf(datafile, "%f\t%f\n", &xvalues[4], &yvalues[4]); fclose(datafile); ///////////////////////////////// //Code for using PGPLOT: ///////////////////////////////// // The cpgbeg function starts a plotting page cpgbeg(0,"?",1,1); // Sets the active drawing colour: 1-black, 2-red, 3-green, 4-blue cpgsci(1); // Sets the active line drawing style: 1-solid, 2-dashed, 3-dot-dashed, 4-dotted cpgsls(1);

15 // Sets the active character height, larger number = bigger cpgsch(1.); // Sets the axes limits cpgswin(xmin,xmax,ymin,ymax); // Draw the axes cpgbox("bcnst", 0.0, 0, "BCNST", 0.0, 0); // Label the bottom axis cpgmtxt("b",3.,.5,.5,"x axis"); // Label the left axis cpgmtxt("l",3,.5,.5,"y axis"); // Sets character height (this time for the title) cpgsch(2.); // Write the title cpgmtxt("t",1,.5,.5,"title"); // Connect 'plotpointcount' points in 'xvalues' and 'yvalues' with a line

16 } cpgsci(7); cpgline(plotpointcount,xvalues,yvalues); // close all pgplot applications cpgend(); return 0; //The 'quadratic' function is defined here: float quadratic(float a,float b,float c,float x) { return (a*x*x)+(b*x)+c; }

17 4 Series and Sequences Series expressions are extremely useful in mathematics and physics, and are often the only solution to a system of equations. By truncating a series at order N, we can find a numerical approximation of the solution, which gets more accurate as N increases. Such is the case for the Gregory Series expansion of π, which can be obtained from Machins Formula 1 4 π = 4 tan 1 ( ) 1 5 ( ) 1 tan (4) and can be seen in Table 2, along with other valid expansions. The Hayashi expansion uses the Fibonacci sequence F n, given by F n = F n 1 + F n 2 (5) where the sequence is seeded by the values F 1 = F 2 = 1. Given their iterative nature, the numerical evaluation of series should be done with loops. Specifi- 17

18 Name Definition (k!) 2 2 k+1 Newton/Euler (2k + 1)! k=0 ( 1) k+1 Gregory 4 2k 1 k=1 N (2k) 2 Wallis 2 (2k 1)(2k + 1) k=1 ( ) 1 Hayashi 4 arctan k=1 F 2k+1 Table 2: Series expression for π 18

19 cally, given the incremental increase of the summed variable, for loops are the most convenient to use. 4.1 Procedure 1. Write a program which uses a loop to print integers 1-10 in the terminal. 2. Write a loop which calculates the first 10 Fibonacci numbers, and print them to the terminal. 3. Write a function which uses a loop to calculate the series expression for π up to order N, using the Euler Method. 4. Investigate the convergence of the formulae for π in Table.2 (by comparison to its exact value) as a function of series truncation N, and produce a table of results. This means you should write code for all of the other series. 19

20 5. Order these series formulae from most to least convergent. 5 Special Functions and Recurrence Relations 5.1 Series Representations of Bessel Functions As an interesting application of numerical evaluation of series expansions, we will now look at the solutions to Bessel s equation, specifically, at Bessel Functions of the First Kind. Bessel s differential equation is given by x 2d2 y dx 2 + xdy dx + (x2 n 2 )y = 0 (6) It is a 2-dimensional wave equation, and has many applications in physics including the notable examples: description of electromagnetic waves in a cylindrical wave-guide, solutions to the radial Schrodinger 20

21 Equation for a free particle, and modes of vibration on a circular drum. (refs) For integer n it has the series solutions J n (x) = where N. N l=0 ( 1) l 2 2l+n l!(n + l)! x2l+n (7) 5.2 Procedure 1. Use the series solution for J n (x) of arbitrary integer order n 1 to write a function bessj(n,x) 2. Generate and plot a data file bessjn.dat for the zeroth- and first-order Bessel functions J 0 (x) and J 1 (x) between 0 x 10 with 1000 data points, using each of N = {10, 50, 200}. 3. Repeat the above step for all Bessel functions of the first kind, J n (x), up to n = 6, using N = 200 terms in the series. (This will require a nested loop). Plot the results. 21

22 6 Matrix Arithmetic 6.1 Background Index Notation Index notation is a way of representing and manipulating matrices in compact form, without direct reference to their elements. In index form the matrix M ij has two indices i and j, representing rows and columns respectively. In this notation vector have one index, representing either rows or columns. The order of indices is important, and reversing i and j is equivalent to taking the transpose of the matrix, i.e. M ij = (M ji ) T. Repeated indices are summed, and only adjacent indices can be summed. If non-adjacent indices need to be summed, the transpose of the matrix must be taken, for example M ji V j is really (M ij ) T V j. In this notation, the summing of an index is equivalent to taking the inner product of that index. For example, the dot product of two vectors A B, can 22

23 be expressed in index notation as A i B i, and the product of a matrix and a vector as M ij A j, etc. In order to sum two indices, they need to be of the same size. This notation is especially useful when performing matrix multiplications numerically, as loops can easily be employed to sum indices Matrix Operations Operations on matrices, while potentially tedious to do analytically, can be done rapidly with the use of numerical techniques. As hinted above loops can be employed to calculate inner products of matrices and vectors. Table3 show a list of basic matrix operations, expressed in index form C Arrays and Matrices C arrays can be generalised to matrices by declaring 2 indices instead of one, i.e. int matrix[2][2]; 1 23

24 Name Addition Subtraction Matrix Multiplication Matrix-Vector Product Transpose Trace Definition M ij + N ij M ij N ij M ij N jk M ij A j M ij = (M ji ) T M ii Table 3: Matrix operations declares a 2 2 matrix of integers with 0 being the index minimum Rotation Matrices The action of rotation is to transform a vector in 3-space into a vector pointing in a different direction, i.e. a different vector in 3-space. We can therefore represent this transformation as a 3 3 matrix R ij (i, j span from 0 to 2), which acts on a 3- dimensional vector producing a new 3-dimensional 24

25 vector pointing in a new direction, i.e. V i = R ij V j. (8) We can go further and decompose R ij into 3 rotations about the coordinate axes, x, y and z, by angles α, β and γ respectively, i.e. R ij = R x (α) ik R y (β) kl R z (γ) lj. (9) An explicit representation of the rotation matrices is given by: R ij = R x (α) ik R y (β) kl R z (γ) lj = cos α sin α 0 sin α cos α cos β 0 sin β sin β 0 cos β cos γ sin γ c Procedure 1. Draw a flowchart for a matrix multiplication function. 25

26 2. Write this function and confirm that your code output for A + B is correct, as well as A C, using these matrices: A ij = ( ), B ij = ( ) and C ij = (11) ( ) 3. Write a function which reads two matrices from data files and tests whether matrix commutativity holds. Use the following matrices: D ij = Exercise: the rotation matrices. and E ij = (12) (a) Write a procedure that performs a sequence of rotations for angles α, β, γ. (b) Take a vector along y axis and perform rotations R x (α) ik R y (β) kl R z (γ) lj

27 (c) Check the commutativity relations on these matrices by direct test. 27