hw6_mth5500_rao_mahi_chernositov.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework 6 - Numerical "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import scipy.stats as ss \n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "plt.style.use('seaborn')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# time index for the data \n",
    "time_index = np.arange(0.01, 1.01, 0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# time incrementing per each value of t\n",
    "time_increment = time_index[1:] - time_index[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simulate 100 paths for the diffusions below on $[0,1]$ using the Euler scheme (see Chapter 7) for a discretization of $0.01$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# standard brownian motion covariance matrix \n",
    "bm_cov = np.reshape(np.array([i if i < j else j for j in time_index for i in time_index]), (1000,1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the standard brownian motion to be implemented \n",
    "brownian_motion = np.insert(np.array([np.linalg.cholesky(bm_cov).dot(np.random.normal(loc=0, \n",
    "                                                                                      scale=1, \n",
    "                                                                                      size=1000)) for _ in range(1000)]), \n",
    "                                      obj=0, values=0, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.16243454,  0.1430891 , ...,  1.33314816,\n",
       "         1.34433853,  1.33842649],\n",
       "       [ 0.        , -0.01532362, -0.09224629, ...,  0.78930145,\n",
       "         0.80977325,  0.85362853],\n",
       "       [ 0.        ,  0.04895166,  0.05650305, ..., -0.58214407,\n",
       "        -0.62641668, -0.66756   ],\n",
       "       ...,\n",
       "       [ 0.        ,  0.09123177,  0.12316604, ..., -0.41851636,\n",
       "        -0.46726075, -0.46452152],\n",
       "       [ 0.        ,  0.12724959,  0.13494298, ...,  0.15002871,\n",
       "         0.20213033,  0.17245073],\n",
       "       [ 0.        , -0.01734895,  0.0174026 , ...,  1.12599052,\n",
       "         1.16349639,  1.17340691]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brownian_motion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the Black-Scholes model under its risk-neutral probability\n",
    "\n",
    "$$ d\\tilde{S_t} = \\sigma \\tilde{S_t} d\\tilde{B_t}, \\ \\ \\ \\ \\ \\ \\  S_0 = 100 \\ \\ \\ \\ \\ \\ \\   \\sigma=0.3$$\n",
    "\n",
    "for some Brownian motion $(\\tilde{B_t})$. For simplicity, assume that the interest rate is 0. Use the pricing formula $\\tilde{O_0}=\\mathop{{}\\mathbb{E}}[\\tilde{O_1}]$ to price the following options with maturity 1\n",
    "using the average over 1000 paths with a discretization of 0.001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$where \\ \\ \\tilde{S_t}= S_0exp(\\sigma \\tilde{B_t} - \\sigma^2 t \\ / \\ 2)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# terminal stock value at time t = 1\n",
    "stock_tilde = 100 * np.exp(0.3 * brownian_motion - 0.5 * np.insert(time_index,0,0) * 0.3**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def present_value(strike:float, maturity:float, risk_free:float=0.0):\n",
    "    return strike*math.exp(-risk_free*maturity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def black_scholes_call(stock:float, strike:float, sigma:float, maturity:float, risk_free:float=0.0):\n",
    "    vol_time = sigma*math.sqrt(maturity)\n",
    "    d1 = (1/vol_time) * (math.log(stock/strike) + (risk_free+(sigma**2/2))*maturity)\n",
    "    d2 = d1 - vol_time\n",
    "    \n",
    "    return ss.norm.cdf(d1)*stock - ss.norm.cdf(d2)*present_value(strike, maturity, risk_free)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Standard Call Option\n",
    "$O_1 = (S_1 - 110)^+$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple call option\n",
    "p1 = round(black_scholes_call(100, 110, 0.3, 1, 0), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = stock_tilde[:,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simulated price for call option, taking average of payouts\n",
    "pA = round(np.average(np.array([i if i>0 else 0 for i in (s1-110)])), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------\n",
      "The price of the option according to black-scholes is:   $8.14\n",
      "Our simulation yeilded a price of                        $8.15\n",
      "-------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"-------------------------------------------------------------------\")\n",
    "print(\"The price of the option according to black-scholes is:   ${}\\nOur simulation yeilded a price of                        ${}\".format(p1, pA))\n",
    "print(\"-------------------------------------------------------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$O_1 = max_{t\\leq 1}S_t$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pB = round(np.average(np.array([max(i) for i in stock_tilde])), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------\n",
      "The price of the option according to the simulation is 126.53.\n",
      "-------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"-------------------------------------------------------------------\")\n",
    "print(\"The price of the option according to the simulation is {}.\".format(pB))\n",
    "print(\"-------------------------------------------------------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$O_1 = exp(\\int^{1}_{0}log S_t \\ dt)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "pC = round(np.average(np.exp(np.average(np.log(stock_tilde), axis=1))), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------------\n",
      "The price of the option according to the simulation is 100.06.\n",
      "-------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"-------------------------------------------------------------------\")\n",
    "print(\"The price of the option according to the simulation is {}.\".format(pC))\n",
    "print(\"-------------------------------------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}