Numpy Exercise 3

Imports



In [1]:

    
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns



In [2]:

    
import antipackage
import github.ellisonbg.misc.vizarray as va









    



Downloading:  https://raw.githubusercontent.com/ellisonbg/misc/master/vizarray.py
Using existing version:  github.ellisonbg.misc.vizarray

Geometric Brownian motion

Here is a function that produces standard Brownian motion using NumPy. This is also known as a Wiener Process.



In [3]:

    
def brownian(maxt, n):
    """Return one realization of a Brownian (Wiener) process with n steps and a max time of t."""
    t = np.linspace(0.0,maxt,n)
    h = t[1]-t[0]
    Z = np.random.normal(0.0,1.0,n-1)
    dW = np.sqrt(h)*Z
    W = np.zeros(n)
    W[1:] = dW.cumsum()
    return t, W

Call the brownian function to simulate a Wiener process with 1000 steps and max time of 1.0. Save the results as two arrays t and W.



In [4]:

    
t,W=brownian(1.0, 1000)
t=np.array(t)
W=np.array(W)



In [5]:

    
assert isinstance(t, np.ndarray)
assert isinstance(W, np.ndarray)
assert t.dtype==np.dtype(float)
assert W.dtype==np.dtype(float)
assert len(t)==len(W)==1000

Visualize the process using plt.plot with t on the x-axis and W(t) on the y-axis. Label your x and y axes.



In [6]:

    
plt.plot(t, W) #plots the function with the x- and y-axes labeled
plt.xlabel('t')
plt.ylabel('W(t)')









    Out[6]:





<matplotlib.text.Text at 0x7f757fd75790>



In [7]:

    
assert True # this is for grading

Use np.diff to compute the changes at each step of the motion, dW, and then compute the mean and standard deviation of those differences.



In [8]:

    
dW=np.diff(W) #calculated difference, std deviation and mean
dW.mean(), dW.std()









    Out[8]:





(-0.0011603363588671709, 0.031765714333234496)



In [9]:

    
assert len(dW)==len(W)-1
assert dW.dtype==np.dtype(float)

Write a function that takes $W(t)$ and converts it to geometric Brownian motion using the equation:

$$ X(t) = X_0 e^{((\mu - \sigma^2/2)t + \sigma W(t))} $$

Use Numpy ufuncs and no loops in your function.



In [14]:

    
def geo_brownian(t, W, X0, mu, sigma):
    "Return X(t) for geometric brownian motion with drift mu, volatility sigma."""
    X_t=X0*np.exp((mu-(0.5*sigma**2))*t+sigma*W)
    return X_t #creates the X_t function using np.exp()



In [15]:

    
assert True # leave this for grading

Use your function to simulate geometric brownian motion, $X(t)$ for $X_0=1.0$, $\mu=0.5$ and $\sigma=0.3$ with the Wiener process you computed above.

Visualize the process using plt.plot with t on the x-axis and X(t) on the y-axis. Label your x and y axes.



In [18]:

    
plt.plot(geo_brownian(t,W,1.0,0.5,0.3))
plt.xlabel('t'), plt.ylabel('W(t)') #plots the geometric brownian









    Out[18]:





(<matplotlib.text.Text at 0x7f757fc96d90>,
 <matplotlib.text.Text at 0x7f757fab39d0>)



In [19]:

    
assert True # leave this for grading