Math 56 Homework 1 Michael Downs. ne n 10 + ne n (1)

Transcription

1 . Problem (a) Yes. The following equation: ne n + ne n () holds for all n R but, since we re only concerned with the asymptotic behavior as n, let us only consider n >. Dividing both sides by n( + ne n ) we get e n + ne n n () From here we need only to observe that we can pick C = and any n R + such that e n + ne n C n () holds for all n > n. We conclude that (b) We are interested in the N such that and so e n +ne n = O(n ). 6 N log N N (4) 6 log N N (5) We first note that this holds for < N because log is negative or zero for these values. We would expect the RHS to become larger than the LHS for large N because N grows exponentially relative to log N. I use the following code to create a matlab plot: f i g u r e ; hold on ; h = e z p l o t ( ˆ6 l o g ( x ), [ 5]) ; s e t (h, Color, r ) ; 5 e z p l o t ( x, [ 5]) ; t i t l e ( ˆ6 l o g ( x ) vs x ) ; 7 legend ( ˆ6 l o g ( x ), x ) ;

2 x 7 6 log(x) vs x 5 6 log(x) x x x 7 and so the N for which (5) holds is between.5 7 and 7. Using a solver we see that 6 log N = N when N So 6 N log N outperforms N for N I start by writing a matlab script to find the average maximum eigenvalue λ max of matrices with dimension n with random entries from the standard normal distribution for n from to using steps of with trials per step (so trials at, trials at, at, etc. I take the average result of the trials as the value at dimension n). Some sample values are tabulated below: n λ max We observe that λ max grows slowly relative to n. A log-log plot of λ max vs n reveals a linear relationship:

3 log log plot of λ max vs n λ max n We then have the relationship: log λ max = a + b log n (6) Using linear regression we obtain a.94 and b.5 For positive n, we can rewrite this equation: log λ max = a + b log n log λ max = log c + log n b log λ max = log cn b λ max = cn b Solving log c =.94 we get c = e which gives us the experimental relationship λ max (n).4679n.55. Finally, I check this fitted equation s accuracy by plotting it against the experimental data:

4 Comparison to determine accuracy 9 Experimental data Fitted regression x Thus we can be satisfied that λ max (n).4679n.55. Code used to make the plots: % s c r i p t to e x p l o r e the r e l a t i o n s h i p between the maximum e i g e n v a l u e o f a % symmetric matrix o f dimension n with random e n t r i e s from the standard % normal d i s t r i b u t i o n. In s t e p s o f, the s c r i p t i t e r a t e s from to % using t r i a l s f o r each i t e r a t i o n to determine the average maximum 5 % e i g e n v a l u e. We then p l o t the data. 7 e i g s = z e r o s (, ) ; % dummy matrix to hold the e i g e n v a l u e s x = : : ; % the x v a l u e s in the p l o t 9 y = z e r o s (, ) ; % the y v a l u e s in the p l o t f o r n = : : f o r i = : ; A = randn ( n ) ; 5 A = A + A ; e i g s (, i ) = max( e i g (A) ) ; 7 end y (, n/) = mean( e i g s ) ; 9 end % code to get the i n i t i a l l o g p l o t l o g l o g ( x, y ) ; t i t l e ( log l o g p l o t o f \ lambda {max} vs n ) ; x l a b e l ( n ) ; 5 y l a b e l ( \ lambda {max} ) ; 7 % g e t t i n g the c o n s t a n t s p=p o l y f i t ( l o g ( x ), l o g ( y ), ) ; 9 b=p ( ) ; 4

5 a=exp ( p ( ) ) ; syms x ; S = a ( xˆb ) ; 5 % and then the comparison p l o t f i g u r e ; 7 hold on ; h = p l o t ( x, y ) ; 9 h = e z p l o t (S, [ ] ) ; hold o f f ; 4 t i t l e ( Comparison to determine accuracy ) ; 4 s e t ( h, c o l o r, r, l i n e s t y l e, ) ; legend ( Experimental data, F i t t e d r e g r e s s i o n ) ;. Looking up what the series converges to: y = k= k 4 = π4 9. (a) I first write this script in matlab to produce a plot and get the equation for the line. 4 6 % s c r i p t to p l o t the e r r o r o f the truncated n term s e r i e s o f /kˆ4 vs n format long g ; % more accuracy syms k ; % the lower and upper bounds, r e s p e c t i v e l y. assume s t e p s o f 8 lb = ; ub = ; x = lb : ub ; y = z e r o s (, ub ) ; % dummy matrix to hold the y v a l u e s f o r p l o t t i n g l a t e r 4 f o r i = lb : ub y (, i ) = abs (symsum( kˆ 4, lb, i ) pi ˆ4/9) ; 6 end 8 l o g l o g ( x, y ) ; t i t l e ( log l o g p l o t o f \ e p s i l o n n vs n ) ; x l a b e l ( n ) ; y l a b e l ( \ e p s i l o n n ) ; p = p o l y f i t ( l o g ( x ), l o g ( y ), ) ; 4 b = p ( ) ; a = exp ( p ( ) ) ; A log-log plot of ɛ n vs n reveals a linear relationship with a downward slope: 5

6 log log plot of ε n vs n 4 5 ε n n Therefore, we can expect a relationship between ɛ n and n of the form: log ɛ n = log(a) + b log n (7) with a > and b <. Performing linear regression on the data we get log a.9 so a = e.9.74 and the slope b.9689 (which is close enough to ). Linearity in a log-log plot is indicative of algebraic convergence. (b) Not too useful. It tells us that the error converges to zero rapidly but it s difficult to interperet other meaningful data, such as the rate of convergence, from the plot. With a log-log plot, the slope of the line is the rate of convergence. It s not as clear if both axes are linear. (c) We have that ɛ n = k>n k 4 and so ɛ n n k 4 dk = implies that n = O(ɛ n ). n so ɛ n = O(n ) which (d) The order does matter due to the nature of floating point precision. If we start the sum at the beginning and sum n terms, we re starting with the largest terms so the smaller terms later on in the series might not change the answer (they ll get absorbed). If we start n terms out and sum backwards to the first term, we start by summing several smaller terms which eventually become larger and give an actual contribution once we reach the large terms. So summing in reverse would be more accurate. Terms after n = 4 will be ignored because they re smaller than 6 and matlab only stores 6 digits of relative accuracy. I explore this hypothesis in matlab using the following script: % t e s t i n g a sum in r e v e r s e format long g ; forw = ; % the forward sum 6

7 5 rev = ; % the r e v e r s e sum n = ; % the terms 7 f o r i = : n 9 forw = forw + / i ˆ 4 ; end f o r i = : n rev = rev + /(( n+) i ) ˆ 4 ; end 5 f p r i n t f ( Forward : %d Error : %d\n, forw, abs ( pi ˆ4/9 forw ) ) ; 7 f p r i n t f ( Reverse : %d Error : %d\n, rev, abs ( pi ˆ4/9 rev ) ) ; For small n, the error starts off the same. As I increase n, first the forward sum becomes more accurate, then the reverse some becomes more accurate for really large n. >> HWQPD Output for n = Forward:.8e+ Error:.8667e-7 Reverse:.8e+ Error:.8667e-7 >> HWQPD Output for n = Forward:.8e+ Error:.8e- Reverse:.8e+ Error:.8e- >> HWQPD Output for n = Forward:.8e+ Error: e- Reverse:.8e+ Error:.669e- >> HWQPD Output for n = Forward:.8e+ Error: e- Reverse:.8e+ Error: >> HWQPD Output for n = Forward:.8e+ Error: e- Reverse:.8e+ Error:.446e-6 >> HWQPD Output for n = Forward:.8e+ Error: e- Reverse:.8e+ Error:.446e-6 I conclude that the order does not matter for small n but we get better precision using the reverse sum for large n. 4. Code below: 7

8 % f i n d s an approximate root o f f ( x ) by b i s e c t i o n. given two p o i n t s % a < c with f ( a ) and f ( c ) o p p o s i t e sign, t h i s w i l l keep g e t t i n g the % midpoint o f a and c, s e e i n g how c l o s e the f u n c t i o n i s to zero with that % value, and then r e p e a t i n g the p r o c e s s u n t i l i t i s within the t o l e r a n c e 5 f u n c t i o n root = b i s e c t i o n ( f, a, c, t o l, n ) 7 n = n + ; % the method breaks down i f f ( a ) and f ( c ) have the same s i g n so we 9 % should stop i f that s the case i f s i g n ( f ( a ) ) == s i g n ( f ( c ) ) f p r i n t f ( e r r o r, same s i g n s ) ; r eturn ; end 5 root = ( a+c ) / ; % the midpoint between a and c zero = f ( root ) ; % the e v a l u a t i o n o f the midpoint. should become c l o s e 7 % to zero 9 % stop and r eturn an answer i f we re c l o s e enough to zero i f abs ( zero ) <= t o l n r eturn ; end 5 % o t h e r w i s e perform a r e c u r s i o n to get a more a c curate answer % we must be c a r e f u l to c o n s i d e r the s i g n change that occurs at the 7 % root i f f ( c ) > 9 i f zero > root = b i s e c t i o n ( f, a, root, t o l, n ) ; e l s e i f zero < root = b i s e c t i o n ( f, root, c, t o l, n ) ; end e l s e i f f ( c ) < 5 i f zero > root = b i s e c t i o n ( f, root, c, t o l, n ) ; 7 e l s e i f zero < root = b i s e c t i o n ( f, a, root, t o l, n ) ; 9 end end 4 end (a) Code below: % t e s t s c r i p t f o r the b i s e c t i o n f u n c t i o n f x ) s i n ( x ) ; 5 7 b i s e c t i o n ( f,, 4,., ) % t h i s f i n d s the c o r r e c t root, pi. 8

9 9 b i s e c t i o n ( f,, pi,., ) % t h e r e should be no r o o t s in t h i s i n t e r v a l but i t g i v e s the root which gives the output >> HWQ4PA n = ans =.46 n = 5 ans = e-5 (b) Since the error is approximately halved each iteration (we succesively take midpoints until we re close enough to the answer), one would expect the error to exhibit exponential convergence: ɛ n = O( n ). Consider ɛ n = 5. The amount of iterations n required to achieve accuracy to fifteen digits would depend on the starting interval c a but let us assume something reasonable such as c a =. We have that: 5 = n 5 log = n log 5 log = n log n which shows that we would expect around 5 iterations to achieve ɛ n = 5. The trial for finding the root of sin between and 4 took approximately 48 iterations, which is close to the predicted number. Trying to find digits of accuracy is not possible, however, as matlab is not capable of that level of precision. My code 9

10 resulted in a stack overflow due to infinite recursion because the evaluation of the root was never under the tolerance. (c) An advantage of bisection over newton s method is that it does not rely on the function s derivative. This avoids having to find the derivative in the first place and it avoids problems if the derivative is zero or near zero at the root. Also, newton s method does not converge for some functions. 5. Problem 5 (a) i. + i 4 ii. 5 iii. ( + i) iv. 5 (b) Code below: f u n c t i o n m = complot ( f ) [X,Y] = meshgrid ( :. :, :. : ) ; Z = abs ( f (X + i Y) ) ; 4 s u r f (X,Y, Z) end Plotting complex values: >> complot(@(x) x); (c) Below is a plot of the function f(z) = /( + z ) in the complex plane. absolute value of f(z) blows up to infinity near the poles z = ±i. The

11 + x.^)); We can also take a look at how the angles/phases behave near the poles by modifying complot.m: f u n c t i o n m = complot ( f ) [X,Y] = meshgrid ( :. :, :. : ) ; Z = angle ( f (X + i Y) ) ; s u r f (X,Y, Z) 5 end >> complot(@(x)./( + x.^)); >> colorbar

12 4 4 X:. Y: Z: The phase approaches a constant depending on the direction of approach. At each pole, the phase is zero. Approaching the pole from the left or right results in either negative or positive π. There appears to be a discontinuity but we must remember that π = π when talking about angles and the program has to output a single angle so it restricts angles to ( π, π]. (d) Since is closer to. than it is to ±i, we can expect the taylor series to converge. Applying the theorem from class we have that ɛ n = O (.7 n). 6. As from class, F = {± m β t β e,, ±, NAN}. We can represent real numbers in the interval [ n, n+ ] with the approximation m β t β e where β =, t = 5, e = n, and β t m β t. Thus the spacing in the interval [ n, n+ ] is 5 n. The spacing is some decimal less than until n = 5 at which point the spacing in the interval [ 5, 5 ] is. We still hit all the integers in this interval and every interval for n 5, however. The first interval where we start to skip integers is the interval [ 5, 54 ] when n = 5. The spacing in this interval is, so 5 + is the smallest integer that is not in F. In conclusion: The smallest positive integer that does not belong to F is n = β t + with β = and t = 5 which is Confirming in matlab: >> fprintf( %f %f \n, ^5, ^5 + ) This code should serve as an identity function because it takes the square root of a number 6 times and then squares it 6 times. In practice, however, roots are often irrational or very long decimals and cannot be expressed precisely by a floating-point system. For most numbers expressible in matlab, after taking the root about 6 times, we end up with a number very close to such that the difference between that number and would be less than 5 at which point the number just becomes. For very large numbers, the returned result is less than the original due to lost precision.

13 x = realmax ( double ) ; f p r i n t f ( b e f o r e : x = %d\n, x ) ; 5 f o r i =:6 x = s q r t ( x ) ; 7 end 9 f o r i =:6 x = x ˆ ; end f p r i n t f ( a f t e r : x = %d\n, x ) ; >> HWQ7 before: x = after: x = >> HWQ7 before: x = after: x = >> HWQ7 before: x =.e+ after: x = >> HWQ7 before: x =.e+ after: x = >> HWQ7 before: x =.e+ after: x =.545e+ >> HWQ7 before: x =.79769e+8 after: x =.8445e+