1 Week 1: Basics of scientific programming I

Transcription

1 MTH739N/P/U: Topics in Scientific Computing Autumn Week 1: Basics of scientific programming I 1.1 Introduction The aim of this course is use computing software platforms to solve scientific and mathematical problems. There are a huge number of options for scientific computing, each with a set of benefits and challenges. They can be classed into overlapping categories (note: these categories do not cover all of computing): Compiler Languages Interpreted Languages Interfaces C, C++ Java Mathematica Fortran Python Maple Pascal Perl R, Matlab, Octave etc. etc. etc. Typically, compiled languages have the advantage of faster running programs (this is always depent on the quality of the code of course!). Interpreted languages are easier to learn and use, but are often slower. Programming interfaces, such as Matlab, Octave or R t to be the slowest option for computing. However, they offer many additional benefits for scientific computing: graphical output (e.g. plotting, 3D plotting) built in functions, often optimised (e.g.. matrix operations, ODE solvers) integrated debugging Therefore, a sensible strategy in scientific computing is to develop algorithms and functions on a high level platform, then translate to higher speed compiled language, if and when it is needed (e.g. stochastic simulations of infectious disease processes). Octave, a free version of Matlab, will be used as the programming language for this module. Students can also use another programming language (C, Fortran, Python, etc.) or programming environment (Maple, Mathematica) if they wish to. However, all code examples and coursework solutions will be provided as Octave/Matlab code. 1

2 1.2 Variables and basic operations Variables, mathematical or otherwise, need to be specified and assigned values. In Matlab/Octave this is done as follows: Command x = 2 x = 2.0 x = text Type integer float string Variables are overwritten with the assignment command = : x = x + 1 There are several conventions that are commonly used in scientific computing for variable names. These are needed to make code easier to share between scientists, and to avoid confusion. Variable names should : have no numbers to start be capital sensitive (language depent) contain no spaces (underscore is used instead; e.g. no spaces) Matlab and Octave contain many predefined constants: π pi i i, j, the imaginary unit e e, Euler s constant Arithmetic operations are preformed by using common symbols: [+] addition [-] subtraction [*] multiplication [/] division [ˆ] exponentiation They follow the usual conventions, with the order of operations being from left to right: 1 + 2*5 = 11 1/4/2 = NOT 0.5! 2

3 Vectors and matrices Vectors and matrices are specified as follows: V = [1 2 3] - row vector n - th element: V(n) V = [1; 2; 3] - column vector ; is the row delimiter A = [1 2 3; 4 5 6; 7 8 9] - matrix A = The elements of this matrix are accessed as follows: Operations A ij = A(i,j) column j : A(:,j) row i : A(i,:) submatrix : A([1:2],[1:3]) Operations on vectors and matrices is similar to operations on variables. A * B - matrix multiplication u * v - vector multiplication has two types of output: scalar if u row vector, v column vector; matrix if u column vector, v row vector A - transpose (also transpose(a)) A^n - matrix exponent, n-th power 3

4 1.3 Basic functions Built in mathematical functions There s a huge number of mathematical functions implemented in Octave/Matlab. Here are just a few: sin(x) cos(x) tan(x) exp(x) asin(x) acos(x) atan(x) log(x),log10(x) sinh(x) cosh(x) tanh(x) sqrt(x) = xˆ(1/2) real(x) imag(x) mod(a,b) factorial(n) For the vast majority of built in functions, a description is available by looking at the help files (e.g. help sin). In addition, many custom built functions are available that increase the functionality of the platform. These functions are not only useful for computation and calculation, but input and output of data, data analysis, visualisation and so on. But, mathematical problems will require the expansion of the basic functionality of the platform. In the coursework, and in the project, you will employ built-in functions as long as they don t fulfil the required task. In that case, you should write your own functions! Function fct(x) where x can be of any type (integer, float, matrix, vector, etc.) can be defined as follows: [a,b] = fct(x,y,z...) Functions that are computer specific include: floor(x) - round down to nearest integer ceil(x) - round up to nearest integer Functions can be written in such a way that they give different results for different inputs. For example: max(x) - highest value in vector x min(x) - lowest value in vector x sum(x) - sum of values of vector x prod(x) - product of values of vector x In the case of x being a matrix, these function acts on each of the columns of matrix x in turn and outputs a row vector for each column. This type of multiple output is called function overloading. For matrices, simple matrix operations are implemented: inv(a) - matrix inverse det(a) - matrix determinant 4

5 eig(a) - vector of eigenvalues of A [U,D] = eig(a) - returns U matrix with eigenvectors in columns and D diagonal matrix with corresponding eigenvalues Element-wise operations Most mathematical functions act element-wise. If we have a matrix: ( ) 1 2 A = 3 4 then ( ) sin(1) sin(2) sin(a) = sin(3) sin(4) Element wise operations can be forced onto vectors and matrices:.* - element-wise product.^ - element-wise power./ - element-wise division +,- - always element-wise Examples: A^2 = A.A ( ) 7 10 = ( ) 1 4 A.^2 = and so on. y = [1 2] 1./y = [1 1/2] 1/y = error x = [3 5] x*y = 13 ( ) 3 6 x *y = 5 10 x.*y = [3 10] x*y = error 5

6 1.4 Plotting Octave implements simple plotting commands, the most basic of which is plot(x,y). This plots the points at x,y coordinates. For example if we define an range of x values as follows: x = [0:0.01:10] - this defines a vector of values from 0 to 10 in increments of 0.01 plot(x,sin(x) - this plots sin(x) against x, since sin(x) operates on x in an element-wise fashion. plot(x,x.*sin(x) - this plots sin(x) against x sin(x), since sin(x) operates on x in an element-wise fashion and.* is an element-wise operator Figure 1: Left panel: x against sin(x). Right panel: x against x*sin(x). Multiple lines can be plotted on the same plot using plot(x1,y1,x2,y2,...). The type of line, colour, symbols, can be specified using commands within plot. For example: plot(x1,y1,"cmd1",x2,y2, "cmd2"...), where cmd1 are cmd2 are different. This is important when specifying a leg. Following the plot command, you can specify a leg by executing leg("plot 1","Plot1"). The title of the figure is specified with the command title("text"), and the x and y labels are specified with the commands xlabel("text") and ylabel("text)". And finally, the figure can be saved to file using the print command. For example print -dpdf "name.pdf" produces a file called name.pdf that contains the figure plotted. 6

7 1.5 Procedures and functions It s cumbersome to type out and execute commands each time you want to perform a calculation. To make this easier, and repeatable, we use procedures and functions. Procedure Commands and functions can be executed in consecutive order, automatically, and saved in a text file (e.g. in MATLAB or Octave, the file ing will be.m ). For the code to be usable include comments : % everything after the % sign is a comment and not executed variables defined in procedures are global can include structured execution (conditional, repeated), and built-in functions can be called within other procedures/functions like built-in functions (function files need to be known to the program) Functions Functions are, in essence, procedures that have flexible input and output, using variables. They follow a predefined structure with a specific syntax. function [y1,...,yn] = myfun(x1,...,xm) declares a function named myfun that accepts inputs x1,...,xm and returns outputs y1,...,yn. This declaration statement must be the first executable line of the function. Save the function code in a text file with a.m extension. The name of the file should match the name of the first function in the file. Valid function names begin with an alphabetic character, and can contain letters, numbers, or underscores. You can declare multiple local functions within the same file, or nest functions. If any function in a file contains a nested function, all functions in the file must use the keyword to indicate the of the function. Otherwise, the keyword is optional. used for mathematical functions x f(x). implement complicated functions using structured execution and / or built-in functions variables defined in functions are local Examples 1. Define a function in a file named mypow.m that accepts a variable, and returns a single result. function y = mypow (x) a = 1 / x; y = x ^ a; 7

8 Here a is a local variable, whereas y is a returned variable. This can be made listable, and operate element- wise, by using./ instead of / and.^ instead of ^. 2. Define a function in a file named average.m that accepts an input vector, calculates the average of the values, and returns a single result. function y = average(x) if ~isvector(x) error( Input must be a vector ) n = length(x); % n,s are local variables s = sum(x); % length(x), sum(x) are built-in functions y = s/n; % x can be a scalar or a vector Call the function from the command line as follows, for example: z = 1:99; average(z) ans = A multiple input function can be defined as follows: function norm = mynorm(x,y) norm = sqrt(x^2 + y^2); % two arguments, x and y Alternatively, both the values can be included within a vector x function norm = mynorm(x) % single argument, x vector norm = sqrt(x(1)^2 + x(2)^2); 8

9 4. An arbitrary number of function arguments and outputs is possible: function y = polar(x) % single argument, x vector y(1) = sqrt(x(1)^2 + x(2)^2); y(2) = atan(x(2)/x(1)); % returns y, a vector of length two 5. Two variable output: function [u, y] = rotation(x,theta) % two arguments, two outputs u(1) = x(1) * cos(theta) - x(2) * sin(theta); % rotation u(2) = x(1) * sin(theta) + x(2) * cos(theta); y(1) = sqrt(x(1)^2 + x(2)^2); % polar vector y(2) = atan(x(2)/x(1)); Executing (or calling) this function a = rotation (x,0.5) with x = [1,4] would return only the first output (rotation). Calling this function [a,b] = rotation (x, 0.5) returns a (rotated vector) AND b (polar vector). 6. Matrix eigenvectors: [U,D] = eig(a) returns U matrix with eigenvectors in columns and D diagonal matrix with corresponding eigenvalues. 9