Math 56 Homework 1. Matthew Jin. April 3, e n 10+ne. = O(n 1 ) n > n 0, where n 0 = 0 be- 10+ne

Transcription

1 Math 56 Homework 1 Matthew Jin April 3, a) e n 10+ne is indeed equal to big O of n 1 e as n approaches infinity. Let n n 10+ne n C n 1 for some constant C. Then ne n 10+ne C n Observe that Choose C=1. ne n 10+ne < nen n ne = 1 n = O(n 1 ) n > n 0, where n 0 = 0 be- Then it immediately follows that e cause n 10+ne n 1 whenever n > 0 n e n 10+ne n (b) For this problem we want to find the N for which it is true that 10 6 NlogN < N 2. One way to do this is to find the zeros of the function N(10 6 logn N), and thus determine the range of N for which 10 6 logn N < 0. For N > 0, one therefore evaluates 10 6 logn N = 0. Through MATLAB, one finds that the zero occurs at z = e + 07 and that the graph appears as follows: 1

2 Thus one can see that the range over which an algorithm taking 10 6 NlogN effort is faster than one taking N 2 effort is N > e Pasted below is the code used in this problem: N=0:2*10^7; % graph the function over the range 0 to 2*10^7 format long plot(n,(10^6)*log(n)-n) %produce the graph xlabel( x ) ylabel( y ) f=@(n) (10^6)*log(N)-N; z=fzero(f, 1*10^7) %calculate the zero of the function 2) On average, the maximum eigenvalue of the random symmetric matrix seems to grow as e = n 1 2, where e represents the maximum eigenvalue of the random symmetric matrix. Below is the code in MATLAB used to determine this result, a graph of the data from a run, as well as several runs to confirm that this formula is reasonable. 2

3 clf result=[]; x=[]; for n=1:10:1000 A=randn(n); S=A+A ; %create the n by n random symmetric matrix S maxeig=max(eig(s)); %compute the maximum eigenvalue result=[result maxeig]; x=[x n]; loglog(x,result) %plot the graph of maximum eigenvalue vs. dimension, both on a log scale slope=(log(result(90))-log(result(60)))/(log(90)-log(60)) %determine the slope of this graph from points where the graph is essentially linear

4 Because the graph of the maximum eigenvalue with respect to matrix dimension is roughly linear on a logarithmic scale, one is led to believe that the relationship is of the form e = n p, where p is the slope of the linear graph. The slope p is approximately.5, thus one is led to the conclusion that e = n 1 2. (3) (a) The following code was developed in order to evaluate the n-term truncated approximation of the infinite series for k 4 clf format long result=[]; X=[]; y=(pi^4)/90; %this is the precise value of the infinite series for n=1:10:10000 s=0; for i=1:n, s = s+1/i^4; result=[result s]; %for varying n, compute the sum and store the value X=[X n]; epsn=abs(result-y); %compute the error for each sum loglog(x, epsn, +- ) %plot the error against n, each on a log scale, to determine a relationship slope=(log(epsn(900))-log(epsn(600)))/(log(900)-log(600)) % compute the slope of the resulting linear plot k=1 The graph that this script produces appears as follows: 4

5 The slope of the graph that this script calculates is: One can see that there is a linear relationship between the log of n and the log of error. Thus one is led to believe that error converges algebraically, and that it is therefore of the form ɛ n = n p, where p is the slope of the linear graph and the order of convergence. In this case, one conjectures that the convergence is of order 3, due to the computed slope s proximity to -3. (b) A graph with linear axes is not useful here. This is because the error shrinks far too quickly to be seen on the scale of n, and the graph would thus just look like a straight horizontal line at y=0. 5

6 (c) The n-term error is given by ɛ n = error, evaluate n 1 k 4 dk k 4. To find an upper bound on k>n n 1 k dk = 1 4 3n 3 Therefore, because ɛ n 1 3n 3, ɛ n = O(n 3 ). (d) It does matter in which order one performs the sum. Below is the MATLAB code used to compute the reversed sum, as well as its resulting output: clf format long y = (pi^4)/90; %this is the precise value of the series result=[]; X=[]; for n=1:10:10000 s=0; for i=n:-1:1, s = s+1/i^4; result=[result s]; %for varying n, compute the sum and store the value X=[X n]; epsn=abs(result-y); %compute the error for each sum loglog(x, epsn, +- ) %plot the error against n, each on a log scale, to determine a relationship 6

7 slope=(log(epsn(900))-log(epsn(600)))/(log(900)-log(600)) % compute the slope of the resulting linear plot By summing in reverse, the values at the tail that would be disregarded in a forward sum are combined together and taken into account by the computer. Thus one achieves the full 16-digit accuracy, and the error converges more quickly than it does if the sum is converted in a forward manner. Empirically, one observes this by comparing the slopes that the the scripts output for the error from a foward sum and for the error from a reverse sum. In the former case, the slope was approximately -3.07, whereas in the latter, it was Clearly, the slope produced by the reverse sum is closer to -3, the value to which the slope is converging. All other parameters between the two scripts were held constant, while only varying the direction in which the sum was computed. Thus one can conclude that taking a reverse sum indeed causes the error computation to converge faster, and therefore the reverse sum is more accurate. (4) % This program estimates the root of a function f given a and c, where % f(a) and f(c) are of opposite sign, and a<c. The user must also input 7

8 % an error tolerance greater than or equal to 10^(-15). If the program cannot converge % on a root within 1000 runs, then it will terminate and inform the user % of this. If present in the output, calcroot is the true calculated root. % Otherwise, simply accept ans as the calculated root. Finally, f(a) and % f(c) must each be sufficiently large that f(a) and f(c) are larger than % the error tolerance that the user inputs. function calcroot=h1p4(f,a,c,err) errorestimate=abs(c-a); % variable that computes the difference between c and a runcount=0; % variable to count how many times the while loop has run if err<1*10^(-16) error( error tolerance must be positive and greater than 10^(-16) ) % If the user s error tolerance is too low, then the program will have % trouble converging on a root. if f(a)>0 && f(c)>0 f(a)<0 && f(c)<0 f(a)<err && f(c)<err error( f(a) and f(c) must be of opposite sign and cannot both be zero ) if a>=c error( a must be less than c ) while errorestimate>err b=(a+c)/2; %compute the midpoint value if runcount>1000 error( The program has not been able to converge within 1000 runs ) elseif f(b)<0 && f(a)>0 % reassign the values deping on whether f(a)and % f(b) are positive or negative c=b; elseif f(b)>0 && f(a)>0 a=b; elseif f(b)<0 && f(a)<0 a=b; elseif f(b)>0 && f(a)<0 c=b; elseif f(b)==0 % break from the loop in case f(a), f(b), f(c) are 0 calcroot=b; break elseif f(c)==0 calcroot=c break elseif f(a)==0 calcroot=a 8

9 break errorestimate=abs(c-a); runcount=runcount+1; calcroot=b; (a) The test script appears as follows: The output for this test script is as follows: ans = Error using h1p4 (line 17) f(a) and f(c) must be of opposite sign and cannot both be zero Error in h1p4test (line 3) h1p4(@sin,0,pi, ) One can see that in the first case, the program computes the root at pi as expected. In the second case, both of the given f(a) and f(c) are less than the error bound, so the computer reminds the user that f(a) and f(c) cannot both be zero. (b) The maximum error shrinks by 1/2 with every iteration, so it is of the form ɛ n = ( 1 2 )n and converges exponentially with n. Because ɛ n = ( 1 2 )n where ɛ n represents the maximum error, one might say that, for ɛ n representing the error following the nth iteration, ɛ n = O( 1 2 )n. To find the n needed to find a root to 9

10 a 15-digit accuracy, note that ɛ n would thus be on the order of and one would simply need to evaluate the n for which ( 1 2 )n = This yields a result of n 53.2, or one would need to iterate 54 times or more in order to ensure accuracy to 15 digits. In practice, one cannot demand 20 digits of accuracy, because the computer itself can only store up to 16 digits. My program has trouble converging even for a user-inputted error of , though for an error of the code manages to converge within 51 iterations. (5a) i) 1+1i 1 ii) 3+4i = i 25, Im( 1 3+4i ) = 4 25 iii) e 13pi 4 = cos( 13π 13π 4 ) + isin( 4 ) = 2 2 i 2 2 iv) 5 (5b) The following is the code and the graph it generates: [x,y]=meshgrid(-2:.2:2,-2:.2:2); z=abs(x+1i*y); surf(x,y,z) (5c) The following is the code used for this problem: 10

11 [x,y]=meshgrid(-2:.1:2,-2:.1:2); z=abs(1./(1+(x+1i*y).^2)); figure; surf(x,y,z) figure; theta=atan2(-2.*x.*y,1+x.^2-y.^2); surf(x,y,theta); The following is the graph that reflects the poles in the complex plane for f(x) = 1 1+x 2 : One can see that the poles occur at i and -i. Separating out the imaginary and real components of the function f(x) = 1 1+x to put f in the form a+bi, one 2 determines the phase θ = tan 1 ( b a ) = tan 1 2xy ( 1+x 2 y ). The following is a plot 2 of the phase: 11

12 One observes that in the neighborhood of each pole, as one rotates clockwise in the imaginary plane about the poles, the phase increases by 2pi for every full rotation in the complex plane. (5d) For a rate of convergence r, a big R that represents the distance from the center to the nearest singularity, an x at which the series is evaluated at and an x 0 at which the series is centered, r = x x0 R. In this case, x 0=1, x=.3, and the distance from the center to the nearest singularity is 2 (both are located at +i and -i). Therefore, the convergence rate is ) n = β t Because β = 2 and t = 52 for IEEE double-precision, n = The following is the code and the output that confirms this: a=2^53; b=a+1; 12

13 a==b %check to see if the computer can distinguish between a and a+1 c=a-1; c==a %check to see if hte computer can distinguish between a and a-1 Output: ans = 1 ans = 0 Thus one can see that the computer is unable to distinguish between 2 53 and , yet it is able to distinguish between 2 53 and Thus this confirms that is indeed the smallest n that does not belong to the system. 7. This code should mathematically take 60 roots of a number and then square it 60 times. In practice, for a number larger than 2, the square root function takes a bit of information off of the exponent. For a number smaller than 2, approximately a bit is removed from the mantissa (this can be seen from the Taylor series expansion of x centered at x=1, f(x) = x+1 2 ). Overall, one loses roughly a bit of precision each time the square root function is invoked. Therefore, by invoking the square root function 60 times on a 64 bit system, one loses almost all of the information stored in the original value. This is why when one tests the code for a variety of values: result=[]; for x=10.^[3:300] for i=1:60 x = sqrt(x); for i=1:60 x = x^2; result=[result x]; One gets a vector that has value 1 from 1000 to , e+111 from to , and e+222 from to above. Almost all of the original information is lost, except just enough information remains for the computer to distinguish between the numbers for the stated ranges of values. 13