Codice Python: Geometric Brownian Motion - cosa c'è che non va?

Question

Sono abbastanza nuovo per Python, ma per un documento in università ho bisogno di applicare alcuni modelli, preferibilmente usando Python. Ho passato un paio di giorni con il codice che ho allegato, ma non posso davvero aiutare, cosa c'è di sbagliato, non è la creazione di un processo casuale che assomiglia a movimenti marroniani standard con deriva. I miei parametri come mu e sigma (ritorno atteso o deriva e volatilità) tendono a cambiare nient'altro che la pendenza del processo di rumore. Questo è il mio problema, sembra tutto rumore. Spero che il mio problema è abbastanza specifico, ecco la mia Coode:

import math 
from matplotlib.pyplot import * 
from numpy import * 
from numpy.random import standard_normal 

''' 
geometric brownian motion with drift! 

Spezifikationen: 

    mu=drift factor [Annahme von Risikoneutralitaet] 
    sigma: volatility in % 
    T: time span 
    dt: lenght of steps 
    S0: Stock Price in t=0 
    W: Brownian Motion with Drift N[0,1] 
''' 

T=1 
mu=0.025 
sigma=0.1 
S0=20 
dt=0.01 

Steps=round(T/dt) 

t=(arange(0, Steps)) 
x=arange(0, Steps) 
W=(standard_normal(size=Steps)+mu*t)### standard brownian motion### 
X=(mu-0.5*sigma**2)*dt+(sigma*sqrt(dt)*W) ###geometric brownian motion#### 
y=S0*math.e**(X) 

plot(t,y) 

show() 

Answer 1

Secondo Wikipedia,

Così sembra che

X=(mu-0.5*sigma**2)*t+(sigma*W) ###geometric brownian motion#### 

piuttosto che

X=(mu-0.5*sigma**2)*dt+(sigma*sqrt(dt)*W) 

---

Dal T rappresenta l'orizzonte temporale, credo t dovrebbe essere

t = np.linspace(0, T, N) 

---

Ora, secondo questi esempi Matlab (here e here), sembra

W = np.random.standard_normal(size = N) 
W = np.cumsum(W)*np.sqrt(dt) ### standard brownian motion ### 

non

,

W=(standard_normal(size=Steps)+mu*t) 

Si prega di verificare la matematica, tuttavia, potrei sbagliarmi.

---

Quindi, mettendo tutto insieme:

import matplotlib.pyplot as plt 
import numpy as np 

T = 2 
mu = 0.1 
sigma = 0.01 
S0 = 20 
dt = 0.01 
N = round(T/dt) 
t = np.linspace(0, T, N) 
W = np.random.standard_normal(size = N) 
W = np.cumsum(W)*np.sqrt(dt) ### standard brownian motion ### 
X = (mu-0.5*sigma**2)*t + sigma*W 
S = S0*np.exp(X) ### geometric brownian motion ### 
plt.plot(t, S) 
plt.show() 

cede

Answer 2

Un'implementazione aggiuntivo utilizzando la parametrizzazione della legge gaussiana se la fonction normale (invece di standard_normal) , un po 'più breve.

import numpy as np 

T = 2 
mu = 0.1 
sigma = 0.01 
S0 = 20 
dt = 0.01 
N = round(T/dt) 
# reversely you can specify N and then compute dt, which is more common in financial litterature 

X = np.random.normal(mu * dt, sigma* np.sqrt(dt), N) 
X = np.cumsum(X) 
S = S0 * np.exp(X)