Summary<\/strong><\/h1>\n\n- Monte Carlo simulation is one of the most important algorithms in quantitative finance<\/li>\n
- Monte Carlo simulation can be utilized as an alternative tool to price options ( the most popular option pricing model is based on the Black-Scholes-Merton formula)<\/li>\n<\/ul>\n
How Does Monte Carlo Simulation Work?<\/strong><\/h1>\nBefore demonstrating the implementation of the Monte Carlo algorithm, it’s important to fully comprehend the science behind it. Simply put, Monte Carlo simulation generates a series of random variables that have similar properties to the risk factors which the simulation is trying to simulate.<\/p>\n
The simulation produces a large number of possible outcomes along with their probabilities. In summary, it’s used to simulate realistic scenarios (stock prices, option prices, probabilities…).<\/p>\n
\nNote: Monte Carlo simulations can get computationally expensive and slow depending on the number of generated scenarios.<\/p>\n<\/blockquote>\n
Next, I will demonstrate how we can leverage Monte Carlo simulation to price a European call option <\/span>and implement its algorithm in Python.<\/p>\nPricing a European Call Option Using Monte Carlo Simulation<\/h1>\n
Let’s start by looking at the famous Black-Scholes-Merton formula (1973):<\/p>\n
![](\"https:\/\/storage.ning.com\/topology\/rest\/1.0\/file\/get\/7358081681?profile=RESIZE_710x\")
<\/a><\/p>\n<\/p>\n\n\n<\/div>\n<\/div>\n<\/div>\nEquation 3–1: Black-Scholes-Merton Stochastic Differential Equation (SDE)<\/p>\n
S(t) = Stock price at time <\/span>t<\/em><\/strong><\/p>\nr = Risk free rate<\/strong><\/p>\nσ = Volatility<\/strong><\/p>\nZ(t) = Brownian motion<\/strong><\/p>\nOur goal is to solve the equation above to obtain an explicit formula for <\/span>S(t).<\/strong><\/p>\nWe utilized Euler Discretization Scheme to solve the stochastic equation above. The solution is given by the expression:<\/p>\n<\/p>\n
\n\n\n\n<\/div>\n![\"Image](\"https:\/\/miro.medium.com\/max\/723\/1*c6NBbPOaH_5A9OOEf9FVCg.png\")
<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Equation 3–2: Euler Discretization of SDE<\/p>\n
Let’s apply the logarithm function to equation 3–2 above which will allow a faster implementation in Python (the vectorization process using the numpy package in Python would easily ingest the log version of the solution above).<\/p>\n<\/p>\n
\n\n\n\n<\/div>\n![\"Image](\"https:\/\/miro.medium.com\/max\/701\/1*w-MNPrU0bM0pcy_lZaER4w.png\")
<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Equation 3–3: Euler Discretization of SDE (log version)<\/p>\n
Monte Carlo Implementation in Python<\/strong><\/h1>\nWe will utilize the numpy package and its vectorization properties to make the program more compact, easier to read, maintain and faster to execute. The source code below is available here<\/a>.<\/p>\n#
# Monte Carlo valuation of European call options with NumPy (log version)
# Monte_Carlo.py
#
import math
from numpy import *
from time import time
# star import for shorter code
random.seed(20000)
t0 = time()
# Parameters
S0 = 100.; K = 105.; T = 1.0; r = 0.05; sigma = 0.2
M = 50; dt = T \/ M; I = 250000
# Simulating I paths with M time steps
S = S0 * exp(cumsum((r – 0.5 * sigma ** 2) * dt
+ sigma * math.sqrt(dt)
* random.standard_normal((M + 1, I)), axis=0))
# sum instead of cumsum would also do
# if only the final values are of interest
S[0] = S0
# Calculating the Monte Carlo estimator
C0 = math.exp(-r * T) * sum(maximum(S[-1] – K, 0)) \/ I
# Results output
tnp2 = time() – t0<\/p>\n
print(‘The European Option Value is: ‘, C0) # The European Option Value is: 8.165807966259603
print(‘The Execution Time is: ‘,tnp2) # The Execution Time is: 0.9024488925933838<\/p>\n
Graphical Visualization<\/h1>\n
The graph below displays a plot of the first 10 simulated paths. Those simulated paths represent different outcomes for the price of the underlying asset (index level).<\/p>\n
import matplotlib.pyplot as plt
plt.plot(S[:, :10])
\nplt.grid(True)
\nplt.xlabel('Steps')
\nplt.ylabel('Index level')
\nplt.show()<\/span><\/pre>\n<\/p>\n\n\n\n\n<\/div>\n![\"Image](\"https:\/\/miro.medium.com\/max\/951\/1*nYWO8paEEYaOcHYTEZctuw.png\")
<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Figure 3–1: Simulated index levels by time steps<\/p>\n
Next, let’s investigate the frequency of the simulated index levels at the end of the simulation period.<\/p>\n
plt.rcParams[\"figure.figsize\"] = (15,8)
plt.hist(S[-1], bins=50)
\nplt.grid(True)
\nplt.xlabel('index level')
\nplt.ylabel('frequency')<\/span><\/pre>\n<\/p>\n\n\n\n\n<\/div>\n![\"Image](\"https:\/\/miro.medium.com\/max\/991\/1*ncOFi_zl_bz5FzOgrckcJA.png\")
<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Figure 3–2: Histogram of all simulated end-of-period index values<\/p>\n
Next, let’s look at the histogram of all simulated end-of-period option values.<\/p>\n
import numpy as np
plt.rcParams[\"figure.figsize\"] = (15,8)
\nplt.hist(np.maximum(S[-1] - K, 0), bins=50)
\nplt.grid(True)
\nplt.xlabel('option inner value')
\nplt.ylabel('frequency')
\nplt.ylim(0, 50000)<\/span><\/pre>\n<\/p>\n\n\n\n\n<\/div>\n![\"Image](\"https:\/\/miro.medium.com\/max\/1045\/1*OFXGo2-w4g2x3bBMGj13Ug.png\")
<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Figure 3–3: Histogram of all simulated option values<\/p>\n
We notice something very interesting in the latter plot. The European call option expires worthless the majority of the time. This might be useful information for an astute options trader! But that’s a discussion for another day.<\/p>\n
References<\/h1>\n
Hilpisch, Y. (2015). Python for Finance: Analyze Big Financial Data<\/p>\n
Originally posted here<\/a><\/em><\/p>\n<\/div>\nGo to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
How Does Monte Carlo Simulation Work?<\/strong><\/h1>\nBefore demonstrating the implementation of the Monte Carlo algorithm, it’s important to fully comprehend the science behind it. Simply put, Monte Carlo simulation generates a series of random variables that have similar properties to the risk factors which the simulation is trying to simulate.<\/p>\n
The simulation produces a large number of possible outcomes along with their probabilities. In summary, it’s used to simulate realistic scenarios (stock prices, option prices, probabilities…).<\/p>\n
\nNote: Monte Carlo simulations can get computationally expensive and slow depending on the number of generated scenarios.<\/p>\n<\/blockquote>\n
Next, I will demonstrate how we can leverage Monte Carlo simulation to price a European call option <\/span>and implement its algorithm in Python.<\/p>\nPricing a European Call Option Using Monte Carlo Simulation<\/h1>\n
Let’s start by looking at the famous Black-Scholes-Merton formula (1973):<\/p>\n
<\/a><\/p>\n<\/p>\n\n\n<\/div>\n<\/div>\n<\/div>\nEquation 3–1: Black-Scholes-Merton Stochastic Differential Equation (SDE)<\/p>\n
S(t) = Stock price at time <\/span>t<\/em><\/strong><\/p>\nr = Risk free rate<\/strong><\/p>\nσ = Volatility<\/strong><\/p>\nZ(t) = Brownian motion<\/strong><\/p>\nOur goal is to solve the equation above to obtain an explicit formula for <\/span>S(t).<\/strong><\/p>\nWe utilized Euler Discretization Scheme to solve the stochastic equation above. The solution is given by the expression:<\/p>\n<\/p>\n
\n\n\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Equation 3–2: Euler Discretization of SDE<\/p>\n
Let’s apply the logarithm function to equation 3–2 above which will allow a faster implementation in Python (the vectorization process using the numpy package in Python would easily ingest the log version of the solution above).<\/p>\n<\/p>\n
\n\n\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Equation 3–3: Euler Discretization of SDE (log version)<\/p>\n
Monte Carlo Implementation in Python<\/strong><\/h1>\nWe will utilize the numpy package and its vectorization properties to make the program more compact, easier to read, maintain and faster to execute. The source code below is available here<\/a>.<\/p>\n#
# Monte Carlo valuation of European call options with NumPy (log version)
# Monte_Carlo.py
#
import math
from numpy import *
from time import time
# star import for shorter code
random.seed(20000)
t0 = time()
# Parameters
S0 = 100.; K = 105.; T = 1.0; r = 0.05; sigma = 0.2
M = 50; dt = T \/ M; I = 250000
# Simulating I paths with M time steps
S = S0 * exp(cumsum((r – 0.5 * sigma ** 2) * dt
+ sigma * math.sqrt(dt)
* random.standard_normal((M + 1, I)), axis=0))
# sum instead of cumsum would also do
# if only the final values are of interest
S[0] = S0
# Calculating the Monte Carlo estimator
C0 = math.exp(-r * T) * sum(maximum(S[-1] – K, 0)) \/ I
# Results output
tnp2 = time() – t0<\/p>\n
print(‘The European Option Value is: ‘, C0) # The European Option Value is: 8.165807966259603
print(‘The Execution Time is: ‘,tnp2) # The Execution Time is: 0.9024488925933838<\/p>\n
Graphical Visualization<\/h1>\n
The graph below displays a plot of the first 10 simulated paths. Those simulated paths represent different outcomes for the price of the underlying asset (index level).<\/p>\n
import matplotlib.pyplot as plt
plt.plot(S[:, :10])
\nplt.grid(True)
\nplt.xlabel('Steps')
\nplt.ylabel('Index level')
\nplt.show()<\/span><\/pre>\n<\/p>\n\n\n\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Figure 3–1: Simulated index levels by time steps<\/p>\n
Next, let’s investigate the frequency of the simulated index levels at the end of the simulation period.<\/p>\n
plt.rcParams[\"figure.figsize\"] = (15,8)
plt.hist(S[-1], bins=50)
\nplt.grid(True)
\nplt.xlabel('index level')
\nplt.ylabel('frequency')<\/span><\/pre>\n<\/p>\n\n\n\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Figure 3–2: Histogram of all simulated end-of-period index values<\/p>\n
Next, let’s look at the histogram of all simulated end-of-period option values.<\/p>\n
import numpy as np
plt.rcParams[\"figure.figsize\"] = (15,8)
\nplt.hist(np.maximum(S[-1] - K, 0), bins=50)
\nplt.grid(True)
\nplt.xlabel('option inner value')
\nplt.ylabel('frequency')
\nplt.ylim(0, 50000)<\/span><\/pre>\n<\/p>\n\n\n\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
Figure 3–3: Histogram of all simulated option values<\/p>\n
We notice something very interesting in the latter plot. The European call option expires worthless the majority of the time. This might be useful information for an astute options trader! But that’s a discussion for another day.<\/p>\n
References<\/h1>\n
Hilpisch, Y. (2015). Python for Finance: Analyze Big Financial Data<\/p>\n
Originally posted here<\/a><\/em><\/p>\n<\/div>\nGo to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Note: Monte Carlo simulations can get computationally expensive and slow depending on the number of generated scenarios.<\/p>\n<\/blockquote>\n
Next, I will demonstrate how we can leverage Monte Carlo simulation to price a European call option <\/span>and implement its algorithm in Python.<\/p>\n Let’s start by looking at the famous Black-Scholes-Merton formula (1973):<\/p>\n Equation 3–1: Black-Scholes-Merton Stochastic Differential Equation (SDE)<\/p>\n S(t) = Stock price at time <\/span>t<\/em><\/strong><\/p>\n r = Risk free rate<\/strong><\/p>\n σ = Volatility<\/strong><\/p>\n Z(t) = Brownian motion<\/strong><\/p>\n Our goal is to solve the equation above to obtain an explicit formula for <\/span>S(t).<\/strong><\/p>\n We utilized Euler Discretization Scheme to solve the stochastic equation above. The solution is given by the expression:<\/p>\n<\/p>\n Equation 3–2: Euler Discretization of SDE<\/p>\n Let’s apply the logarithm function to equation 3–2 above which will allow a faster implementation in Python (the vectorization process using the numpy package in Python would easily ingest the log version of the solution above).<\/p>\n<\/p>\n Equation 3–3: Euler Discretization of SDE (log version)<\/p>\n We will utilize the numpy package and its vectorization properties to make the program more compact, easier to read, maintain and faster to execute. The source code below is available here<\/a>.<\/p>\n # print(‘The European Option Value is: ‘, C0) # The European Option Value is: 8.165807966259603 The graph below displays a plot of the first 10 simulated paths. Those simulated paths represent different outcomes for the price of the underlying asset (index level).<\/p>\n Figure 3–1: Simulated index levels by time steps<\/p>\n Next, let’s investigate the frequency of the simulated index levels at the end of the simulation period.<\/p>\n Figure 3–2: Histogram of all simulated end-of-period index values<\/p>\n Next, let’s look at the histogram of all simulated end-of-period option values.<\/p>\n Figure 3–3: Histogram of all simulated option values<\/p>\n We notice something very interesting in the latter plot. The European call option expires worthless the majority of the time. This might be useful information for an astute options trader! But that’s a discussion for another day.<\/p>\n Hilpisch, Y. (2015). Python for Finance: Analyze Big Financial Data<\/p>\n Originally posted here<\/a><\/em><\/p>\n<\/div>\n Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"Pricing a European Call Option Using Monte Carlo Simulation<\/h1>\n
<\/a><\/p>\n<\/p>\n
<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\nMonte Carlo Implementation in Python<\/strong><\/h1>\n
# Monte Carlo valuation of European call options with NumPy (log version)
# Monte_Carlo.py
#
import math
from numpy import *
from time import time
# star import for shorter code
random.seed(20000)
t0 = time()
# Parameters
S0 = 100.; K = 105.; T = 1.0; r = 0.05; sigma = 0.2
M = 50; dt = T \/ M; I = 250000
# Simulating I paths with M time steps
S = S0 * exp(cumsum((r – 0.5 * sigma ** 2) * dt
+ sigma * math.sqrt(dt)
* random.standard_normal((M + 1, I)), axis=0))
# sum instead of cumsum would also do
# if only the final values are of interest
S[0] = S0
# Calculating the Monte Carlo estimator
C0 = math.exp(-r * T) * sum(maximum(S[-1] – K, 0)) \/ I
# Results output
tnp2 = time() – t0<\/p>\n
print(‘The Execution Time is: ‘,tnp2) # The Execution Time is: 0.9024488925933838<\/p>\nGraphical Visualization<\/h1>\n
import matplotlib.pyplot as plt
plt.plot(S[:, :10])
\nplt.grid(True)
\nplt.xlabel('Steps')
\nplt.ylabel('Index level')
\nplt.show()<\/span><\/pre>\n<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\nplt.rcParams[\"figure.figsize\"] = (15,8)
plt.hist(S[-1], bins=50)
\nplt.grid(True)
\nplt.xlabel('index level')
\nplt.ylabel('frequency')<\/span><\/pre>\n<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\nimport numpy as np
plt.rcParams[\"figure.figsize\"] = (15,8)
\nplt.hist(np.maximum(S[-1] - K, 0), bins=50)
\nplt.grid(True)
\nplt.xlabel('option inner value')
\nplt.ylabel('frequency')
\nplt.ylim(0, 50000)<\/span><\/pre>\n<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\nReferences<\/h1>\n