#13
plot(10*e^(0.05*x), (x,0,100))

def EulerMethod(Nprime,init,stepsize,time):
    values = [init]
    for i in srange(0,time + stepsize, stepsize):
        Euler = init + stepsize*Nprime(init) #Euler's Method
        values.append(Euler)
        init = Euler #output becomes new input
    return values
Nprime(x)=0.05*x
time=srange(0,100,1)
print zip(time,EulerMethod(Nprime,10,1,100))

#Trial 1 Stepsize = 1
#The simulation with the stepsize of 1 is similar to the true solution, but deviates as time progresses.
plot(10*e^(0.05*x), (x,0,100))+list_plot(zip(srange(0,100+1,1),EulerMethod(Nprime,10,1,100)), color="red")

#Trial 2 Stepsize = 0.1
#The simulation with the stepsize of 0.1 is very similar to the true solution, and deviates very slightly as time progresses.
plot(10*e^(0.05*x), (x,0,100))+list_plot(zip(srange(0,100+0.1,0.1),EulerMethod(Nprime,10,0.1,100)), color="red")

#Trial 3 Stepsize = .01
#The simulation with the stepsize of 0.01 is, of the three trials, the most similar to the true solution and doesn't appear to deviate at all.
time=srange(0,100,.1)
plot(10*e^(0.05*x), (x,0,100))+ list_plot(zip(srange(0,100+0.01,0.01),EulerMethod(Nprime,10,0.01,100)), color="red")

#14
#For this problem, you can generate a list of values for vector N using the function you created in the previous examples. 
#You have been given the original solution, which is X(t) = X(0) e^0.05t , 
#create a for loop which runs in a list of time values similar to the one you used do determine N. 
    #Say you used time steps of 0.1 and till time=100, your list would be srange(0,100.1,0.1). 
    #Run the for loop through this list i.e. "for i in srange(0,100.1,0.1):" and 
    #calculate the values of X(t) at all this time values within this for loop and 
    #append the values into an empty list. 
        #Now you have lists of both N and a list say R , representing the true solution
    #Now use a for loop again to determine the error for each element of the corresponding lists and 
    #append them to another new list say "err". 
        #This will give you a list of numbers which are the values of the errors for the corresponding values of the two lists. 
        #You can further use " sum(err) " to calculate the sum of all the individual  errors between the elements of the two lists. All of this might sound intimidating but it is just a few lines of code. Give it a try.

#Error for stepsize of 1
true_list = []
actualsolution(t)=10*e^(0.05*t)
nums = srange(0,101,1)
for t in nums:
    true_list.append(actualsolution(t))
true_list

time = srange(0.,100.,1)
Xprime(t)=0.05*t
euler_list1=EulerMethod(Xprime,10,1,100)
euler_list1

error_list1=[]
for (x,y) in zip(euler_list1,true_list):
    a=abs(x-y)/y
    error_list1.append(a)
error_list1

sum(error_list1)/len(error_list1)

#Error for stepsize of 0.1
true_list01 = []
actualsolution(t)=10*e^(0.05*t)
nums = srange(0,100.,0.1)
for t in nums:
    true_list01.append(actualsolution(t))
true_list01

time = srange(0.,100.,1)
Xprime(t)=0.05*t
euler_list01=EulerMethod(Xprime,10,0.1,100)
euler_list01

time = srange(0.,100.,1)
Xprime(t)=0.05*t
euler_list01=EulerMethod(Xprime,10.,0.1,100)
euler_list01

error_list01=[]
for (x,y) in zip(euler_list01,true_list01):
    a=abs(x-y)/y
    error_list01.append(a)
error_list01

sum(error_list01)/len(error_list01)

#Error for stepsize of 0.01
true_list001 = []
actualsolution(t)=10*e^(0.05*t)
nums = srange(0,100.,0.01)
for t in nums:
    true_list001.append(actualsolution(t))
true_list001

time = srange(0.,100.,1)
Xprime(t)=0.05*t
euler_list001=EulerMethod(Xprime,10.,0.01,100)
euler_list001

error_list001=[]
for (x,y) in zip(euler_list001,true_list001):
    a=abs(x-y)/y
    error_list001.append(a)
error_list001

sum(error_list001)/len(error_list001)

#Error decreases as step sizes become smaller