AMTH142 Lecture 10. Scilab Graphs Floating Point Arithmetic

Transcription

1 AMTH142 Lecture 1 Scilab Graphs Floating Point Arithmetic April 2, 27 Contents 1.1 Graphs in Scilab Simple Graphs Line Styles Multiple Curves Multiple Plots Titles and Captions Other Features D Curves Histograms Floating Point Arithmetic Representation of Floating Point Numbers Precision Exceptional Values Rounding Cancellation

2 1.1 Graphs in Scilab Simple Graphs The simplest graph takes two vectors and plots one against the other: -->x = (-2:.1:2); -->y = sin(x)./x; -->plot2d(x,y) You should have noticed the use of the dot operator. To see why it is necessary first note that x is a vector. So is sin(x) whose components are obtained by applying the sin function element-by-element to the vector x. To construct the vector y whose components are obtained by applying the function sin x/x element-by-element to the vector x we preform element-byelement division of the vector sin(x) by the vector x. Scilab graphs joins points by straight lines which sometimes gives the graph a slight polygonal look. If you want a smooth looking graph you need to take a fairly dense of points, 1 will usually do, for the x-coordinates. We can also plot a single vector, whose components are plotted against 1, 2,..., n where n is the length of the vector. First we use clf to clear the graphics window and then plot the components of the vector y used earlier: -->clf -->plot2d(y) 2

3 Notice the different scaling on the x-axis. Here is another example: -->x = linspace(-1, 1, 1); -->y = 2*sin(x) + 3*sin(2*x) + 7*sin(3*x) + 5*sin(4*x); -->clf, plot2d(x,y) In this example linspace(-1,1,1) produces a vector which consists of 1 evenly spaced points between -1 and 1. Also note that we can use commas or semicolons to separate two or more commands on the one line. 3

4 1.1.2 Line Styles The graphs we have looked at so far were of continuous curves. Data can also be plotted as points by using the style option to the plot2d command. Negative values for style correspond to different types of points, positive values for style correspond to different colours. You can use the xset() command to bring up a menu to set different styles and colours as well as things like line thickness. -->x = rand(1,1); -->y = rand(1,1); -->clf, plot2d(x,y,style = -1) Multiple Curves We can plot multiple curves, one on top of the other, by plotting them successively without clearing the screen. Alternatively, if y is a matrix, the command plot2d(x, y) plots each of the columns of the matrix y as a separate curve. In this case x has to be a column vector the same length as the columns of y. We could also plot the curves in different styles, by setting style to a vector of style numbers. -->x = linspace(-1, 1, 1) ; -->y1 = 2*sin(x); y2 = 3*sin(2*x); -->y3 = 7*sin(3*x); y4 = 5*sin(4*x); 4

5 -->y = y1 + y2 + y3 + y4; -->clf, plot2d(x,[y1 y2 y3 y4 y]) Note that the use of the transpose to define x as a column vector. Then each of y1, y2, y3, y4, and y is also a column vector and [y1 y2 y3 y4 y] is a 5 column matrix Multiple Plots Multiple graphs can included in one figure using the subplot command. -->clf -->subplot(2,2,1) -->plot2d(x,y1) -->subplot(2,2,2) -->plot2d(x,y1+y2) -->subplot(2,2,3) -->plot2d(x,y1+y2+y3) -->subplot(2,2,4) -->plot2d(x,y1+y2+y3+y4) 5

6 Titles and Captions Titles and captions can be added, after a graph has been drawn, using the xtitle command. It takes three arguments the title for graph, the caption for the x-axis and the caption for the y-axis. If you don t need a title just use a blank string, i.e.. -->x = -2:.1:2; -->clf, plot2d(x, sin(x)./x) -->xtitle( A TITLE, x, sin(x)/x ) sin(x)/x A TITLE x 6

7 Note the unusual placement of the axis labels. There is nothing that I am aware of that you can do about this Other Features There a lot more Scilab can do with graphs, for example -->clf, plot2d(x, sin(x)./x, rect=[ ],... -->axesflag=5) In this example, the rect option sets the bounds on the x and y axes and the axesflag=5 places the axes so that they cross at the origin (, ). The latest version (3.1.1) of Scilab seems to have much enhanced graphics facilities. Try Scilab s help if you want more information D Curves Curves in 3 dimensional space can be plotted using param3d. It takes three vectors containing the values the x, y and z coordinates of the points on the curve. By clicking on the 3D Rot button on the graphics window and playing around with the mouse you can alter the orientation of the graph. Here is a 3-D spiral: -->z = :.1:1; -->clf, param3d(z.*sin(5*z), z.*cos(5*z), z) 7

8 Z Y X Histograms Histograms can be plotted with the histplot(n, data) command. Here n is the number of bins in the histogram and data is the vector of data for which we want to draw the histogram. The following example draws a histogram from a vector of normally distributed random numbers. -->rr = rand(1,1, normal ); -->clf, histplot(1, rr)

9 1.2 Floating Point Arithmetic Representation of Floating Point Numbers The arithmetic used by Scilab is called floating point arithmetic. Scientific notation is used to express floating point numbers; the number is written in Scilab as e-6. Internally floating point numbers are stored in a binary format known as IEEE double precision arithmetic. Each floating point number occupies 64 bits, which contain the sign, digits and exponent of the number. The details of the binary representation are not usually important in practical applications, but the finite precision of floating point numbers has some important implications: 1. Each floating point number is capable of representing about 16 decimal digits (actually 53 bits). 2. There is a limit on the range of exponents; from about 1 38 to (actually to ). The most important consequence of this is that it is impossible to calculate with more than 16 digits precision. This, in itself, is not a problem since it is rare in practical applications to require more accuracy than this. However it can happen that much less accuracy is attained in actual calculations due to rounding errors Precision The usual measure of precision in floating point arithmetic is the number machine epsilon, written ε mach, and defined to be difference between the number 1 and the next largest floating point number. In IEEE arithmetic the number 1 has the representation 1 } {{ } 52bits and the next largest floating point number is 1 } {{ 1 } 52bits Thus ε mach =

10 In Scilab ε mach is denoted by %eps. -->%eps %eps = 2.22E-16 To check the defining property of ε mach, note that -->(1 + %eps) - 1 ans = 2.22E-16 -->(1 + %eps/2) - 1 ans =. In floating point arithmetic if we add ε mach to 1 we get a number different to 1, while if add half this much the result is still Exceptional Values Besides the usual floating point numbers, IEEE arithmetic has two special numbers Inf, for infinity, and Nan, for not-a-number. Inf typically occurs when we try try to produce a number whose exponent is greater than the maximum exponent: -->z = 1e3 z = >w = z*z w = Inf This is called overflow. It is easy to recognize when overflow has occurred since an Inf always results. If the result of a calculation has exponent less than the smallest exponent, the result is set to zero. This is called underflow and, while it is usually harmless it can sometimes cause unexpected errors. 1

11 -->z = 1e-3 z = >w = z*z w =. The following shows some ways Nan s can arise: -->z = (1e3)^2 z = Inf -->w = *z w = Nan -->w = z - z w = Nan Rounding When arithmetic operations are preformed on floating point numbers the exact result will not, in general, be representable as a floating point number. The exact result will be rounded to the nearest 1 floating point number, a process called, obviously enough, rounding. In IEEE arithmetic all results of floating point operations are correctly rounded, something that was rarely done on early computers. We will look at an example to give an idea of the rounding process using base 1 arithmetic (although as pointed out above computers use binary arithmetic). Suppose we are doing arithmetic with, say, 5 decimal digits precision. Let x = y = In the case of a tie, the round to even rule is used. 11

12 then, in exact arithmetic, x + y = x y = x y = and these are rounded to x + y = x y = x y = respectively. Rounding errors are unavoidable in numerical computation due to the finite precision of floating point arithmetic. The relative error due to rounding is less than 1/2ε mach , but this can be expected to occur in every floating point operation, including binary/decimal conversion on reading/writing floating point numbers Cancellation Cancellation error occurs when two nearly equal numbers are subtracted. Consider the calculation -->x = x = >y = y = -->x-y ans = E-12 Here x is a 16 digit approximation to π while y agrees with π to 12 digits. What is the error in the calculation? We know the relative error due to rounding is less than 1/2ε mach The problem is that in converting x and y from decimal to 12

13 binary, that is approximating x and y by floating point numbers, we have relative errors of the same magnitude. Thus the absolute error in x is E abs 1/2ε mach x with the same size error in y. We would expect the same size error in their difference, giving a relative error of about E rel / = Any number that is not an exact floating point number, and this includes the results of almost all calculations, will have a relative error of the order of 1/2ε mach. Whenever two such numbers which are nearly equal are subtracted, cancellation error will occur giving a result with less precision than the original numbers. Example An instructive example of cancellation error occurs when we approximate the derivative of function by a formula such as f (x) f(x + h) f(x) h As h gets smaller and smaller the approximation gets better until in the limit as h we get the definition of the derivative. Computing with this formula has the numerical problem that as h gets smaller, f(x + h) and f(x) get closer together and cancellation error will occur. In fact if h is small enough, f(x + h) and f(x) will be represented by the same floating point numbers giving the approximation f (x). We will take f(x) = sin x and approximate the derivative at x = 1 using values of h from 1 2 down to 1 16 : -->n = -2:-2:-16 n =! ! -->h = 1.^n h = 1.E-8 * 13

14 column 1 to 6! ! column 7 to 8!.1 1.E-8! Note (1) the use of the dot operator and (2) how Scilab puts a scale factor outside of the array. -->approx = (sin(1+h) - sin(1))./h approx = column 1 to 4! ! column 5 to 8! ! The error in the approximation is: -->err = approx - cos(1) err = column 1 to 4! E-9! column 5 to 8! E ! At first the main cause of error is the approximation itself and the error decreases as h decreases. At h = 1 1 the error begins to increase. The main cause of error now is cancellation and the error increases rapidly until at h = 1 16 the approximate derivative is zero and totally useless. 14