M & M Homework WK3

Callahan:
    2.2 - 1, 2, 3, 8, 9, 10, 11, 14,
    2.3 - 6, 7, 8, 9, 10, 11

    1)  Modify SIRVALUE and SIRPLOT to analyze the population of poland.  We assume the population P(t) satisfies the conditions:

    where is years since 1985.  We want to know P 100 years into the future; you can assume that P does not exceed 100,000,000.

    a)  Estimate the population in 2085:

    So the population after 100 years is about 92 million.

from visual.graph import*
tinitial = 0
tfinal = 100

graph = gdisplay()

t = tinitial
p = 37500000
numberofsteps = 150
deltat = (tfinal - tinitial)/float(numberofsteps)
pcurve = gcurve(color = (1, 0, 0))
print t, p
pcurve.plot(pos = (t, p))
    
for k in range(1,numberofsteps+1) :
        pprime = (0.009)*p
        deltay = pprime*deltat
        t = t + deltat
        p = p + deltay
        print t, p
        pcurve.plot(pos = (t, p))

    b)  Sketch the graph that describes this population growth:

    2)  By modifying SIRVALUE in the way we modified SIRPLOT to get SEQUENCE, obtain a sequence of estimates for y(37) that allow you to specify the exact value of y(37) to two decimal places accuracy.

    So the value is .

tinitial = 0
tfinal = 37
t = tinitial
p = 100


inc = 0

for inc in range(1,11):
    print t, p
    t = tinitial
    p = 100
    numberofsteps = 100000*inc
    deltat = (tfinal - tinitial)/float(numberofsteps)
    print deltat
    
    for k in range(1,numberofsteps+1) :
        pprime = (0.1)*p*(1-(p/1000))
        deltay = pprime*deltat
        t = t + deltat
        p = p + deltay  

    3)

    a)  Referring to the graph of y(t) obtained in the text on page 70, what can you say about the behavior of y as t gets large?

    It looks like the as t gets large y will approach 1000.

    b)  Suppose we had started with y(0)=1000.  How would the population have changed over time?  Why?

    The y value would just stay at 1000 because the rate of change would be zero..

    c)  Suppose we had started with y(0)=1500.  How would the population have changed over time?  Why?

    The y value would decrease until it reached 1000 because the rate of change is negative and will increase until it reaches zero at large t.

    d)  Suppose we had started with y(0)=0.  How would the population have changed over time?  Why?

    The y value would stay at 0 because the rate of change is zero. This behavior corresponds to an initial population of 0, so there can be no population growth.

    e)  The number 100 in the denominator of the rate equation is called the carrying capacity of the system.  Can you give a physical interpretation of this number?

    The carrying capacity is the sustainable population that the habitat can support.  If the population is above this then it will die back until it reaches the carrying capacity.  Similarly, if the population starts bellow the carrying capacity then it will increase until it reaches it.

    8) Each Euler approximation is made up of a certain number of straight line segments.  What instruction in the program SEQUENCE determines the number of segments in a particular approximation?

    The first graph drawn has only a single segment.  How many does the fifth have?  How many does the fourteenth have?

    The fifth has segments, and the fourteenth has segments.

    9) What is the slope of the first graph?

    So we just use the logistics equation to find the slope:

    And so the slope is 9.

    What are the slopes of the two parts of the second graph?

    The slope of the first section is 9.

    The slope of the second section is about 24.61.

    10) Modify the line in the program SEQUENCE which determines the number of steps by having it read:

    Again we are getting a sequence of approximations, with the number of steps increasing each time, but the approximations don't seem to be getting all that close to anything.  Explain why this modified program isn't as effective for our purposes as the original.

    The modified program isn't as effective for our purposes as the original because the number of steps is not increasing as fast.  The old program had the number of steps growing exponentially while this program only has them growing linearly..

    11) Modify SEQUENCE to produce a sequence of Euler approximations to the function that satisfies the conditions:

from visual.graph import *
graph = gdisplay()

y = 1

for j in range(1,15):
    print j, y
    tinitial = 0
    tfinal = 10
    t = tinitial
    y = 1
    numberofsteps = 2**(j-1)
    deltat = (tfinal - tinitial) / float(numberofsteps)
    
    curve = gcurve()
    curve.plot(pos=(t,y))

    for k in xrange(numberofsteps):
        yprime = (0.2)*5*y*(1-y/5)
        deltay = yprime * deltat
        t = t + deltat
        y = y + deltay
        curve.plot(pos=(t,y))

    a) What is ?

    So is .

    b) Sketch the graph that is the limit of these approximations.  The right half of the limit graph has a distinctive feature; what is it?

    The right half of the limit graph approaches .

    c) Without doing any calculations, can you estimate the value of ?

    You can see from the graph and from the equation that the carrying capacity is 5.  So at any time greater than the graph will just get closer to .

    d) Change the initial conditions from y(0)=1 to y(0)=9,  Construct the sequence of Euler approximations beginning with number of steps equal to 1, and sketch the limit graph.  What is y(10) now?

...
y = 9
for j in range(1,15):
    ...
    y = 9
    numberofsteps = 2**(j+2)
    ...

    So is .

    Explain why the first several approximations look so strange.

    The slope of the limit graph is initially large and negative, so when there are few steps then the Euler approximation oscillates wildly because is large.

    14) Construct a sequence of Euler approximations to the function that satisfies:

    Estimate .  How accurate is your estimate?  (the answer is )

    So it looks like my estimate for is accurate to the third decimal place.

2.3 - 6, 7, 8, 9, 10, 11

    6) Modify the program so that it uses 20 segments to estimate the length of the parabola.  What is the estimated length value?

from math import sqrt

def fnf(x) :
    return x ** 2

xinitial = 0
xfinal = 1
numberofsteps = 20
deltax = (xfinal - xinitial) / float(numberofsteps)
total = 0
for k in range(numberofsteps) :
    xl  = xinitial + k*deltax
    xr = xinitial + (k + 1)*deltax
    yl = fnf(xl)
    yr = fnf(xr)
    segment = sqrt((xr - xl) ** 2 + (yr - yl) ** 2)
    total = total + segment
    print k, segment

print numberofsteps, total

    The estimated length value is:

    7) Modify the program so that it estimates the length of the parabola using 200, 2000, 20000, 200000, and 2000000 segments.

from math import sqrt

def fnf(x) :
    return x ** 2

for j in range(1,6):
    xinitial = 0
    xfinal = 1
    numberofsteps = 20*(10**j)
    deltax = (xfinal - xinitial) / float(numberofsteps)
    total = 0

    for k in range(numberofsteps) :
        xl  = xinitial + k*deltax
        xr = xinitial + (k + 1)*deltax
        yl = fnf(xl)
        yr = fnf(xr)
        segment = sqrt((xr - xl) ** 2 + (yr - yl) ** 2)
        total = total + segment

    print numberofsteps, total

    8) What is the length of the parabola over the interval , correct to 8 decimal places?  What is the length correct to 12 decimal places?

    How about just 11 decimal places:

    9) Starting at the origin, and moving along the parabola , where are you when you've gone a total distance of 10?

from math import sqrt

def fnf(x) :
    return x ** 2

xinitial = 0
xfinal = 5
numberofsteps = 20*(10**5)
deltax = (xfinal - xinitial) / float(numberofsteps)
total = 0

for k in range(numberofsteps) :
    xl  = xinitial + k*deltax
    xr = xinitial + (k + 1)*deltax
    yl = fnf(xl)
    yr = fnf(xr)
    segment = sqrt((xr - xl) ** 2 + (yr - yl) ** 2)
    total = total + segment
    if total >= 10:
        print total, 'x = ', xr, 'y = ',yr
        break

    10) Modify the program to find the length of the curve over the interval .  Find a value that is correct to 8 decimal places.

    Looks like I got it to 11 decimal places.

from math import sqrt

def fnf(x) :
    return x ** 3

for j in range(1,8):
    xinitial = 0
    xfinal = 1
    numberofsteps = 2*(10**(j-1))
    deltax = (xfinal - xinitial) / float(numberofsteps)
    total = 0

    for k in range(numberofsteps) :
        xl  = xinitial + k*deltax
        xr = xinitial + (k + 1)*deltax
        yl = fnf(xl)
        yr = fnf(xr)
        segment = sqrt((xr - xl) ** 2 + (yr - yl) ** 2)
        total = total + segment

    print numberofsteps, total

    11) Consider the unit circle centered at the origin.  The Pythagorean theorem shows that a point is on the circle if and only if .  If we solve this for in terms of , we get , where the plus sign gives us the upper half, and the minus sign gives us the lower half.  This suggests that we look at the function .  The arclength of over the interval should then be exactly .

    a)  Divide the interval into 100 pieces and find the corresponding length:

from math import sqrt

def fnf(x) :
    return sqrt(1-(x**2))

xinitial = 0
xfinal = 1
numberofsteps = 50
deltax = (xfinal - xinitial) / float(numberofsteps)
print deltax
total = 0

for k in range(numberofsteps) :
    xl = xinitial + k*deltax
    xr = xinitial + (k+1)*deltax
    yl = fnf(xl)
    yr = fnf(xr)
    segment = sqrt((xr - xl) ** 2 + (yr - yl) ** 2)
    total = total + segment
    print total, yl, yr, xl, xr

print 2*numberofsteps, 2*total

    b)  How many pieces do you have to divide the interval into to get an accuracy equal to that of Archimedes?

    So, it looks like 65 pieces gives me 2 decimal points of accuracy.

    c)  Find the length of the curve to 8 decimal places of accuracy.

from math import sqrt

def fnf(x) :
    return sqrt(1-(x**2))

for j in range(1,9):
    xinitial = 0
    xfinal = 1
    numberofsteps = 2*(10**(j-1))
    deltax = (xfinal - xinitial) / float(numberofsteps)
    total = 0

    for k in range(numberofsteps) :
        xl  = xinitial + k*deltax
        xr = xinitial + (k + 1)*deltax
        yl = fnf(xl)
        yr = fnf(xr)
        segment = sqrt((xr - xl) ** 2 + (yr - yl) ** 2)
        total = total + segment

    print 2*numberofsteps, 2*total