Options-Pricing-Monte-Carlo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Setting seed, just so you get similar results in case you want to use this code.\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To make these Random paths, we will use Geometric Brownian Motion, our simple assumption here is that the logarithm of stock prices follows a Geometric Brownian Motion.\n",
    "\n",
    "![](https://jdsupra-html-images.s3-us-west-1.amazonaws.com/36ac8b9f-d89d-4e5b-a62c-33e1f441d118-Geometric_Brownian_Motion_graphic_Opportune_LLP.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### S<sub>t</sub> is the stock price at time t, S<sub>0</sub> is price at time t = 0.\n",
    "\n",
    "#### (μ - σ<sup>2</sup>/2)t is also known as **drift**\n",
    "\n",
    "#### ε is a random variable that follows Standard Normal Distribution ~ N(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize some parameters\n",
    "\n",
    "stockPrice = 1000 # The actual spot/underlying price of the asset\n",
    "timeToExpiration = 1/12  # 1 month \n",
    "riskFreeRate = 0.04 # Risk Free Interest Rate\n",
    "volatility = 0.2 # Annual Risk/Standard Deviation/Volatility of the underlying stock/asset\n",
    "strikePrice = 1020\n",
    "\n",
    "\n",
    "numSimulations = 5000 # Number of Monte Carlo Simulations\n",
    "\n",
    "numDays = 21 # Roughly 21 Trading days in a month on an average\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Since we are doing this for daily prices, we need to normalize t\n",
    "\n",
    "t = timeToExpiration / numDays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 21)"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's define drift\n",
    "\n",
    "drift = (riskFreeRate - (volatility**2)/2) * t\n",
    "\n",
    "# Let's assign σ * √t to another variable to make things easier\n",
    "\n",
    "a = volatility * np.sqrt(t)\n",
    "\n",
    "# Let's define ε\n",
    "\n",
    "epsilon = np.random.normal(0,1,(numSimulations,numDays))\n",
    "\n",
    "epsilon.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5000, 21)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       ...,\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.],\n",
       "       [0., 0., 0., ..., 0., 0., 0.]])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priceMatrix = np.zeros((numSimulations,numDays))\n",
    "\n",
    "print(priceMatrix.shape)\n",
    "\n",
    "priceMatrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign the initial stock price value in the first column(t=0)\n",
    "\n",
    "priceMatrix[:,0] += stockPrice\n",
    "\n",
    "# Now let's start filling other column values using GBM(Geometric Brownian motion)\n",
    "for i in range(1,numDays):\n",
    "    priceMatrix[:,i] += priceMatrix[:,i-1] * np.exp(drift + a * epsilon[:,i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1000.        ,  998.33877998, 1006.59854738, ...,  970.25217711,\n",
       "         953.21647127,  971.05861197],\n",
       "       [1000.        , 1000.9305732 ,  983.20205134, ...,  921.99840725,\n",
       "         930.69038995,  932.77598296],\n",
       "       [1000.        ,  996.29270414,  977.98353351, ...,  978.88646986,\n",
       "         976.6769597 ,  963.23441791],\n",
       "       ...,\n",
       "       [1000.        ,  991.28232493,  988.97715768, ...,  913.32364137,\n",
       "         902.40042845,  898.23443517],\n",
       "       [1000.        , 1006.87357652, 1012.74313696, ..., 1014.38166864,\n",
       "        1013.33183478, 1004.17524221],\n",
       "       [1000.        ,  985.48719324,  992.24428683, ..., 1040.61533222,\n",
       "        1036.62677061, 1043.64366385]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priceMatrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's calculate the payoffs now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Payoff for call = Last value in priceMatrix(spot value at expiration) - strikePrice\n",
    "\n",
    "callPayoffMatrix = priceMatrix[:,-1] - strikePrice\n",
    "\n",
    "# Eliminate Negative Payoffs\n",
    "\n",
    "for i in range(len(callPayoffMatrix)):\n",
    "    if callPayoffMatrix[i] < 0:\n",
    "        callPayoffMatrix[i] = 0\n",
    "    \n",
    "# Payoff for Put = strikePrice - Last value in priceMatrix(spot value at expiration)\n",
    "\n",
    "putPayoffMatrix = strikePrice - priceMatrix[:,-1] \n",
    "\n",
    "# Eliminate Negative Payoffs\n",
    "\n",
    "for i in range(len(putPayoffMatrix)):\n",
    "    if putPayoffMatrix[i] < 0:\n",
    "        putPayoffMatrix[i] = 0\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "callPayoff = callPayoffMatrix.mean()\n",
    "putPayoff = putPayoffMatrix.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15.682364946825674, 32.36537917718196)"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callPayoff, putPayoff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Continous discounting for today's price\n",
    "\n",
    "call = callPayoff * np.exp(-riskFreeRate * timeToExpiration)\n",
    "put = putPayoff * np.exp(-riskFreeRate * timeToExpiration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15.63017742452852, 32.25767418796686)"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "call, put\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* #### The Call Option(Out of the money - Only has time value) is priced at 15.63 for a strike price of 1020 when the underlying stock price is 1000.\n",
    "\n",
    "* #### The Put Option(In the Money - has both Time value and intrinsic value) is priced at 32.25.\n",
    "\n",
    "* #### Next steps - Compare the prices with Black Scholes Options Pricing Model (you will find that the prices are quite similar)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}