SBT 645 Introduction to Scientific Computing in Sports Science #6

Transcription

1 SBT 645 Introduction to Scientific Computing in Sports Science #6 SERDAR ARITAN Biyomekanik Araştırma Grubu Spor Bilimleri Fakültesi Hacettepe Universitesi, Ankara, Türkiye De Motu Animalium G.Borelli (1680) 1

2 General philosophy of errors and exception handling Any program may encounter errors during its execution. For the purposes of illustrating exceptions, we ll look at the case of a word processor that writes files to disk and that therefore may run out of disk space before all of its data is written. There are various ways of coming to grips with this problem. SOLUTION 1: DON T HANDLE THE PROBLEM The simplest way of handling this disk-space problem is to assume that there will always be adequate disk space for whatever files we write, and we needn t worry about it. Unfortunately, this seems to be the most commonly used option. It s usually tolerable for small programs dealing with small amounts of data, but it s completely unsatisfactory for more mission-critical programs. 2

3 General philosophy of errors and exception handling SOLUTION 2: ALL FUNCTIONS RETURN SUCCESS/FAILURE STATUS The next level of sophistication in error handling is to realize that errors will occur and to define a methodology using standard language mechanisms for detecting and handling them. There are various ways of doing this, but a typical one is to have each function or procedure return a status value that indicates if that function or procedure call executed successfully. Normal results can be passed back in a call-by-reference parameter. 3

4 General philosophy of errors and exception handling SOLUTION 3: THE EXCEPTION MECHANISM It s obvious that most of the error-checking code in the previous type of program is largely repetitive: it checks for errors on each attempted file write and passes an error status message back up to the calling procedure if an error is detected. The disk space error is handled in only one place, the top-level save_to_file. function save_to_file(filename) try to execute the following block save_text_to_file(filename) save_formats_to_file(filename) save_prefs_to_file(filename).... except that, if the disk runs out of space while executing the above block, do this...handle the error... 4

5 General philosophy of errors and exception handling The act of generating an exception is called raising or throwing an exception. The act of responding to an exception is called catching an exception, and the code that handles an exception is called exception-handling code, or just an exception handler. Depending on exactly what event causes an exception, a program may need to take different actions. For example, an exception raised when disk space is exhausted needs to be handled quite differently from an exception that is raised if we run out of memory, and both are completely different from an exception that arises when a divide-by-zero error occurs. 5

6 Getting an exception at the command line If the function in which the error occurred is implemented as a MATLAB program file, the error message should include a line that looks something like this: surf Error using surf (line 49) Not enough input arguments. The text includes the name of the function that threw the error (surf, in this case) and shows the failing line number within that function's program file. Click the line number; MATLAB opens the file and positions the cursor at the location in the file where the error originated. You may be able to determine the cause of the error by examining this line and the code that precedes it. 6

7 Getting an exception in your program code When you are writing your own program in a program file, you can catch exceptions and attempt to handle or resolve them instead of allowing your program to terminate. When you catch an exception, you interrupt the normal termination process and enter a block of code that deals with the faulty situation. This block of code is called a catch block. Some of the things you might want to do in the catch block are: Examine information that has been captured about the error. Gather further information to report to the user. Try to accomplish the task at hand in some other way. Clean up any unwanted side effects of the error. 7

8 Generating a new exception When your program code detects a condition that will either make the program fail or yield unacceptable results, it should throw an exception. This procedure Saves information about what went wrong and what code was executing at the time of the error. Gathers any other pertinent information about the error. Instructs MATLAB to throw the exception. 8

9 Exception Handling The MException Class The object has four properties: identifier, message, stack, and cause. Each of these properties is implemented as a field of the structure that represents the MException object. The syntax of the MException constructor is ME = MException(identifier, message) 9

10 try surf catch ME ME end Exception Handling ME = MException with properties: identifier: 'MATLAB:nargchk:notEnoughInputs' message: 'Not enough input arguments.' cause: {0x1 cell} stack: [1x1 struct] 10

11 Exception Handling try surf catch ME msg = ME.message; end msg = Not enough input arguments. 11

12 Exception Handling A Try-Catch block provides user-controlled error-trapping capabilities. That is, with a Try-Catch block, errors found by MATLAB are captured, giving the user the ability to control how MATLAB responds to errors. try catch end (commands 1) (commands 2) Here all MATLAB expression in ( commands 1 ) are executed. If no MATLAB errors are generated, control is passed to the end statement. However, if a MATLAB error appears while executing ( commands 1 ), control is immediately passed to the catch statement and subsequent expression ( commands 2 ). Within the catch block the function lasterr contains the string generated by the error encountered in the try block. 12

13 x = ones(4, 2); y = 4*eye(2); Exception Handling % y = 4*eye(3) % try the wrong one try z = x*y; catch z = nan; disp( x and y are not comformable ); end >> lasterr ans = Error using ==> * Inner matrix dimensions must agree. 13

14 Throw an Exception When your program detects a fault that will keep it from completing as expected or will generate erroneous results, you should halt further execution and report the error by throwing an exception. The basic steps to take are 1 Detect the error. This is often done with some type of conditional statement, such as an if or try/catch statement that checks the output of the current operation. 2 Construct an MException object to represent the error. Add a message identifier string and error message string to the object when calling the constructor. 3 If there are other exceptions that may have contributed to the current error, you can store the MException object for each in the cause field of a single MException that you intend to throw. Use the addcause method for this. 4 Use the throw or throwascaller function to have the MATLAB software issue the exception. 14

15 Exception Handling A = rand(3); B = ones(5); try C = [A; B]; catch err % Give more information for mismatch. if (strcmp(err.identifier,'matlab:catenate:dimensionmismatch')) msg = sprintf('%s',... 'Dimension mismatch occured: First argument has ',... num2str(size(a,2)), ' columns while second has ',... num2str(size(b,2)), ' columns.'); error('matlab:mycode:dimensions', msg); % Display any other errors as usual. else rethrow(err); end end % end try/catch 15

16 Working With Files The easiest way of writing and reading files in the MATLAB environment is by means of the functions save and load. While the former allows for saving all or some of the current workspace variables into a file, the latter allows for reading variables previously stored in a file and loading them into the workspace. By default, the two functions save and load, use the MATLAB proprietary format, in which variables names and their corresponding values are written to a formatted binary file with extension.mat 16

17 Working With Files >> clear % deletes all variables in the workspace >> a = [1 2; 3 4]; % creates some variables >> b = {'Hello','World','!'}; c.f1 = 'Hello'; c.f2 = 'World!'; >> save % saves the workspace into default file matlab.mat >> clear % deletes all variables in the workspace >> load % restores the workspace from default file matlab.mat >> whos Name Size Bytes Class Attributes a 2x2 32 double b 1x3 358 cell c 1x1 374 struct 17

18 Working With Files % save all variables into the file allworkspace.mat >> save('allworkspace'); >> % save only variables b and c into the file somevariables.mat >> save('somevariables','b','c'); >> clear % deletes all variables in the workspace % loads only variable a from the file allworkspace.mat >> load('allworkspace','a'); >> clear % deletes all variables in the workspace >> A = [1 2 3; 4 5 6]; >> save mydata.txt A ascii % To import (read) the array >> load mydata.txt >> A = load( mydata.txt ) 18

19 Working With Files The fopen function opens a file and returns a file id number for use with the file. fid = fopen(filename, permission) [fid, message] = fopen(filename, permission) [fid, message] = fopen(filename, permission, format) where filename is a string specifying the name of the file to open, permission is a character string specifying the mode in which the file is opened, and format is an optional string specifying the numeric format of the data in the file. If the open is successful, fid will contain a positive integer after this statement is executed and message will be empty string. If the open fails, fid will contain a -1 after this statement is executed, message will be a string explaining the error. The format string in the fopen function specifies the numeric format of the data is stored in the file. This string is only needed when transferring files between computers with incompatible numeric data formats, so it is rarely used. The fclose function close a file. status = fclose(fid) status = fclose( all ) where fid is a file id and status is the result of the operation. If the operation is successful, status will be zero. If it is unsuccessful status will be -1. fclose ( all ) closes all open files except for stdout(fid=1) and stderr(fid=2). 19

20 File Permission r r+ w w+ a a+ Format native or n ieee-le or l ieee-be or b Working With Files Meaning Open an existing file for reading only Open an existing file for reading and writing Delete the contents of an existing file (or create a new file) and open it for writing Delete the contents of an existing file (or create a new file) and open it for reading and writing Open an existing file (or create a new file) and open it for writing only, appending to the end of the file Open an existing file (or create a new file) and open it for reading and writing only, appending to the end of the file ieee-le.l64 or a ieee-le.l64 or s Meaning Numeric format for the machine MATLAB is executing on IEEE floating point with little-endian byte ordering IEEE floating point with big-endian byte ordering IEEE floating point with little-endian byte ordering and 64-bit long data type IEEE floating point with big-endian byte ordering and 64-bit long data type 20

21 Working With Files % ASCII File Access % open the file fid = fopen('square_mat.txt', 'wt'); % write the header fprintf(fid, '%s\n', 'This is a square matrix'); % write data to file fprintf(fid, '%i\t%i\t%i\n', [1 2 3; 4 5 6; 7 8 9]'); % close file fclose(fid); disp('write of file is successful!... press spacebar to continue') % read the file back in pause % open the file fid=fopen('square_mat.txt', 'rt'); % read in the header title = fgetl(fid); % read in data [data,count]=fscanf(fid, '%i',[3,3]); % close the file fclose(fid); 21

22 Working With Files 22

23 x = 0:.1:1; A = [x; exp(x)]; Working With Files fileid = fopen('exp.txt','w'); fprintf(fileid,'%6s %12s\n','x','exp(x)'); fprintf(fileid,'%6.2f %12.8f\n', A); fclose(fileid); >> id1 = fopen( data1, r ) id1 = 3 >> id2 = fopen( data2, r ) id2 = 4 23

24 Working With Files There are two MATLAB functions for reading and saving a very specific type of CSV files: csvwrite and csvread. These functions allow for writing and reading a matrix of numerical values into a CSV formatted file. In this sense, these functions are similar to save and load when the - ascii option is used, but different from them, the numerical values within each file line are separated by commas. >> mtx = rand(3,4); % creates a random-valued matrix of size 3x4 >> csvwrite('mtx.csv',mtx); % saves the matrix into a csv file >> type mtx.csv , , , , , , , , ,

25 Working With Files >> newmtx = csvread('mtx.csv') % loads the matrix into a new variable newmtx = Updated versions of csvwrite and csvread are implemented in dlmwrite and dlmread, which allow for specifying, as an additional input parameter, the delimiter character to be used for either writing or reading the file, respectively. However, similar to csvwrite and csvread, they are also restricted to numerical data. 25

26 Exception Handling Like everything else in Python, an exception is an object. It s generated automatically by Python functions with a raise statement. After it s generated, the raise statement, which raises an exception, causes execution of the Python program to proceed in a manner different than would normally occur. Instead of proceeding with the next statement after the raise, or whatever generated the exception, the current call chain is searched for a handler that can handle the generated exception. If such a handler is found, it s invoked and may access the exception object for more information. If no suitable exception handler is found, the program aborts with an error message. 26

27 Exception Handling Types of Python exceptions: It s possible to generate different types of exceptions to reflect the actual cause of the error or exceptional circumstance being reported. Python provides a number of different exception types: BaseException SystemExit KeyboardInterrupt GeneratorExit Exception StopIteration ArithmeticError FloatingPointError OverflowError ZeroDivisionError AssertionError AttributeError BufferError EnvironmentError IOError OSError WindowsError (Windows) VMSError (VMS) EOFError ImportError LookupError IndexError KeyError MemoryError NameError UnboundLocalError ReferenceError RuntimeError NotImplementedError SyntaxError IndentationError TabError SystemError TypeError ValueError UnicodeError UnicodeDecodeError UnicodeEncodeError UnicodeTranslateError 27

28 Exception Handling Different exception types 28

29 Exception Handling ValueError : input only number example 29

30 Exception Handling ZeroDivisionError : 30

31 Exception Handling ZeroDivisionError : 31

32 Exception Handling IOError and ValueError : 32

33 try Statement The try statement has another optional clause which is intended to define clean-up actions that must be executed under all circumstances. For example: A finally clause is always executed before leaving the try statement, whether an exception has occurred or not. 33

34 try Statement As you can see, the finally clause is executed in any event. In real world applications, the finally clause is useful for releasing external resources (such as files or network connections), regardless of whether the use of the resource was successful. 34

35 Hint : Changing directory is comes in very handy when working in the Python interpreter: >>> import os >>> os.getcwd() # Returns the current working directory 'C:\\Python33' # usually the directory you were in when you started the interpreter >>> os.chdir('/path/to/directory )) # Change the current working directory to 'path/to/directory' 35

36 Working With Files Python provides a built-in function open to open a file, which returns a file object f = open('foo.txt', 'r') # open a file in read mode f = open('foo.txt', 'w') # open a file in write mode f = open('foo.txt', 'a') # open a file in append mode 'b' appended to the mode opens the file in binary mode: 'rb', 'wb', 'ab' should be used to open a binary file in read, write and append mode respectively. This mode should be used for all files that don t contain text. open(filename, mode) The mode argument is optional; 'r' will be assumed if it s omitted. 36

37 Working With Files 37

38 Working With Files Easiest way to read contents of a file is by using the read method. >>> open('foo.txt').read() 'birinci satir\nikinci satir\nüçüncü satir >>> f.close() >>> print(open('foo.txt').read()) >>> birinci satir ikinci satir üçüncü satir >>> Contents of a file can be read line-wise using readline and readlines methods. >>> open('foo.txt').readlines() ['birinci satir\n', 'ikinci satir\n', 'üçüncü satir'] 38

39 Working With Files The readline method returns empty string when there is nothing more to read in a file. >>> f = open('foo.txt') >>> f.readline() 'birinci satir\n >>> f.readline() 'ikinci satir\n' >>> f.readline() 'üçüncü satir\n' >>> f.readline() >>> f.close() 39

40 Working With Files The write method is used to write data to a file opened in write or append mode >>> f = open('fooyaz.txt','w') >>> f.write('a\nb\nc') >>> f.close() 40

41 Working With Files The write method is used to write data to a file opened in append mode >>> f = open('fooyaz.txt', a') >>> f.write( d\n') >>> f.close() 41

42 Working With Files The writelines method is convenient to use when the data is available as a list of lines. >>> f = open('fooyaz.txt', a') >>> f.writelines(['a\n', 'b\n', 'c\n ]) >>> f.close() 42

43 Working With Files Lets try to compute the number of characters, words and lines in a file. Number of characters in a file is same as the length of its contents. >>>def charcount(filename): return len(open(filename).read()) Number of words in a file can be found by splitting the contents of the file. >>>def wordcount(filename): return len(open(filename).read().split()) Number of lines in a file can be found from readlines method >>>def linecount(filename): return len(open(filename).readlines()) 43

44 Working With Files >>> import os >>> os.getcwd() 'C:\\Python33' >>> os.chdir('f:\lectures\python') >>> charcount('bilgrafik.txt') 3206 >>> wordcount('bilgrafik.txt') 205 >>> linecount('bilgrafik.txt') 13 >>> 44