Math 56 Compu & Expt Math, Spring 2014: Homework 1

Transcription

1 Math 56 Compu & Expt Math, Spring 2014: Homework 1 Pawan Dhakal April 9, Asymptotics. e n (a) Is 10 + ne n = O(n 1 ) as n? Prove your answer, i.e. if true, exhibit a C and n 0 in the definition of big-o. Solution: Let f(n) = e n 10 + ne n ; g(n) = n 1. f g = ne n 10 + ne n 1 10 = ne + 1 n 1 since 1 ne n 0 as n e n Therefore, 10 + ne n = O(n 1 ) n > n 0, where C = 1 and n 0 = 0. (b) For what range of N is an algorithm taking 10 6 N log N effort faster than one taking N 2 effort? Solution: Using Mathematica to solve for 10 6 N log N N 2 = 0. N = is the solution. Therefore, the algorithm is faster for 10 6 N log N for 0 < N < Another way to do this: 10 6 N log N = N 2 log log N log N + 6 log 10 = 0 log N N e The following Matlab code creates symmetric n n matrices with elements that are taken from a normal distribution: A = randn(n); S = A+A ; % creates n by n symmetric random matrix S Recall a symmetric matrix is a matrix S such that S = S T where S T is the transpose of S. Given an arbitrary matrix A we can turn it into a symmetric matrix S by setting S = A + A T. The eigenvalues of a symmetric matrix are always real numbers. On average, how does the maximum eigenvalue of this random symmetric matrix grow as a function of n, the dimension of the matrix? Determine this experimentally, giving as explicit a formula as you can. [Hint: go to large n, eg 10 3, but you don t need many datapoints at large n] 1

2 You will find the eig command useful. It will also be helpful to plot the average maximum eigenvalue vs dimension on a log-log scale. Solution: Let λ max = Maximum Eigenvalue of a n by n symmetric random matrix. Figure 1: Plot of Maximum EigenValues of n by n random symmetric matix. Notice the linear shape of the graph for large n. With my matlab code q2.m (see the links on my webpage; also please read the comments for a more detailed explanation of my methods), I calculated the slope of my plot (loglog plot) of the maximum eigenvalues of the n by n matrix as a function of n to be: slope 0.50 yintercept 1 Therefore, λ max e 1 n 0.50, i.e. λ max 2.7 n Consider the series y = k 4. (a) Measure the convergence rate of the error ε n = ŷ n y for the n-term truncated approximation, by plotting ε n vs n. Choose axis types so that the graph appears linear what is the slope? State the type/order of convergence. [Hint: For the exact y either look it up or use the converged ŷ after you ve done d) below!] Solution: All terms for 10 4 k < are not included in the sum y = k 4.

3 ε n = yˆ n y n = k 4 k 4 = k 4 k=n Integral Test: ε n n 1 3 n 3 1 k 4 dk Choose to plot log ε N vs log n to get a linear graph and read the slope directly from the graph by taking two points far from each other but such that they are roughly exhibiting the linearilty of the plot. The slope is equal to -3. Experimentally, the slope has to converge to 3. The error converges algebraically. The order of convergence is -3. Experimentally, I got slope = See q3.m for the code and the results which I have typed in as comments. (b) How useful is a graph with linear axes here? Why? A graph with linear axes helps to get the slope directly, which is the order of convergence. I plotted using the plot command and taking the log of the x and y values. I could then use two data points in the plot to get the slope using rise/run directly. (c) Prove a big-o bound on effort (i.e. n) in terms of desired error ε. [Hint: as in lecture, but then flip the result.] We have, from a) above that ε n 1 3 n 3, i.e. ε n = O(n 3 ) as n with C = 1/3 n > 0. (d) Does it matter in which order you do the sum? Give converged answers for both orderings, and explain which one is more accurate. 1 The order of the sum matters. With reverse ordering, i.e. by taking the sum k 4, the sum is more accurate because with this ordering we are summing from the smallest values to the largest. So the computer thinks that the values are relevant. The plots below show the difference between the orderings. The reversed order graph is a straight line througout while the normal order graph break off from the linearilty at large n. This is because for normal order, all terms for n 10 4 k < are not included in the sum y = k 4. But for reverse order, we are adding small numbers first so the computer finds these small numbers relevant and adds them before getting to larger terms when n 1. k=n

4 Figure 2: Normal Order of the Sum. Notice the linear shape of the graph changes for large n. Figure 3: Reverse Order of the Sum. Notice the linear shape of the graph does not change for large n. 4. Write your own, documented function that finds one approximate root of f(x), a given function of one variable, by bisection: given two starting arguments a < c with f(a) and f(c) of opposite sign, set b = (a + c)/2 then replace the list a, b, c by either a, (a + b)/2, b, or by b, (b + c)/2, c, depending on what the sign of f(b) tells you on which side the root lies, then iterate until you decide when to stop. Your inputs should be a handle to a function, the pair a, c, and an error tolerance; the output the root. It should stop and report if ever the signs don t make sense. See bisection.m. (a) Add a test script for this function which shows it finding the root of sine in [3, 4], also failing gracefully here given the input pair a = 0, c = π. This could be in the same text file. See testbisection.m. And q4.txt (b) State the type of convergence with n, the number of iterations, and give the tightest error bound you can in big-o notation. What n is needed to find a root to 15-digit accuracy? What happens in practice if you demand 20 digits? (These should be answered by thinking, showing working; then you can check with your code.) For n steps, the interval width is ε n = c a 2 n. After n+1 steps, error is ε n+1 = 1 c a 2 2 n = 1 2 ε n. Therefore, ε n+1 ε n = 1. This is a linear convergence. 2

5 x n n c a 2 n ε n = O( 1 2 n ) C = (c a) c a 2 n 15 n log 2) (base 10.) n terms. Doing the same calculation as above, for 20 digit accuracy, we need n = 66 terms. In practice, the computer runs out of significant digits as soon as we demand an error tolerance of or less. Therefore the code for bisection method will keep running because the computer can figure out midpoint of the interval when it is less than We need to get out of this mess. I did this by looking at the number of bisection steps and breaking the loop when the no was bigger than 100. BONUS State one advantage of this method over Newton s method. Although bisection method has slower convergence than Newton s method, we don t need a good initial guess for convergence because Newton s method converges fast only for initial values close to the root. For bisection method, we are guaranteed convergence if we provide a good initial interval where the root lies. 5. Visualizing the complex plane. (a) Compute on paper: i) 2i ii) Im 1/(3 + 4i), iii) e 13πi/4, iv) 1 2i. Solution: i) 2i z = 2i = 2(cos π/2 + i sin π/2) r = z = 2 θ = π/2 z = r(cos θ/2 + i sin θ/2) = 2(cos π/4 + i sin π/4) = 1 + 1i ii) Im 1/(3 + 4i)

6 3 4i z = (3 + 4i)(3 4i) = 3 4i 25 = i Im(z) = iii) e 13πi/4 e 13πi/4 = cos 13π 4 + i sin 13π 4 = cos 3π + π 4 + i sin 3π + π 4 = cos π 4 i sin π 4 = 1 1 i 2 2 iv) 1 2i 1 2i = (1 2i)(1 + 2i) = 5. (b) Make a short Matlab code which makes a 3D height plot of the absolute value of a given function f(z) on the complex plane z = x + iy for x, y [ 2, 2]. [Hint: at some point you ll want to use [X,Y] = meshgrid(...); then apply your function to all complex grid values X+1i*Y at once.] See q5.m. (c) Use your code to make a plot showing the poles (non-smooth points) in the complex plane for f(x) = 1/(1 + x 2 ). What happens to the phase in the neighborhood of each pole? See q5.m and the figure below.

7 Figure 4: Plots of 3D height of the absolute value and of the Phase. The figures on the right are from the view point directly above. The phase in the neighborhood of each pole goes from 0 to π. Looking at the figure above, we see that the phase jumps from π to π. (d) Use the above to predict the convergence rate r of a Taylor series for this f about x = 1 (careful), when evaluated at x = 0.3. [Don t try to generate the series!] For large n, the rate of convergence r is r = x a where x is the evaluation point, a is the ds a expansion point, and ds is the distance to the closest singularity. We have singularities at x = + i. ds = Therefore,.3 1 r Give an exact formula, in terms of β and t, for the smallest positive integer n that does not belong to the floating-point system F, and compute n for IEEE double-precision. Give one line of code, and its output, which demonstrates this is indeed the case. n = β t + 1 does not belong to the floating-point system. For IEEE double-precision, n = Still need to think about this some more. I will submit an update. 7. Let x be any positive number (also try a really large one!). What should the following Matlab code do mathematically, and what does it do in practice? Explain why. for i=1:60, x = sqrt(x); end, for i=1:60, x = x^2; end Answer: The given code should return whatever the value of x at the end of the two loops. In the first loop, x = x.560 at the end of the loop. Then, in the second loop, initially x = x After 60 iterations of x = x 2, x = (x ) 260 = x.

8 But, in practice, the code gives x = 1 even for very large numbers like x = This is because, while taking the square root of a number 60 times, the root gets smaller very quickly with the no of iterations. So, the computer at some point loses track of the seemingly insignifant digits (which are farther than the 16 digit precision limit) after the decimal point, which are actually very important to get back the original x after squaring 60 times in the second of the loops above. If we reverse the order of the loops, there is a slightly different problem even though we should get back the original x after the end of the two loops. In this case, after raising any number (even very small ones) to the power 2 60, the number is too big and the computer returns infinity as the value, so that after taking squre root 60 times we still get infinity as the value of x. If we take a number between -1 and 1 but not zero, the problem is similar but we get zero since the computer now loses track of the digits (which are farther than the 16 digit precision limit) after the decimal point.