Option_pricing_and_delta_hedging.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Option_pricing_and_delta_hedging.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPM2jOxZO7i0mEoIAwYg60G",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/KMeirazhdinov/Quantitative-Finance-project/blob/main/Option_pricing_and_delta_hedging.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "What this file does: \n",
        "\n",
        "\n",
        "1.   Calculates call/put option prices using Black-Scholes formula\n",
        "2.   Calculates the delta of the call/put option using the closed form solution and using the Monte Carlo simulations. \n",
        "3.   Delta hedges the portfolio\n",
        "4.   Performes Euler approximation of the stock price evolution. \n",
        "\n"
      ],
      "metadata": {
        "id": "V9ZRiuBjNTCg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from scipy.stats import norm\n",
        "from ipywidgets import widgets, fixed\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "IUIldQavNYZ1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Class Black_Scholes creates objects that represent a certain risky asset using the several parameters. Parameters will be shown later. \n",
        "\n",
        "The procedure is as follows: \n",
        "\n",
        "\n",
        "\n",
        "1.   Generate paths of the Brownian motion for the corresponding time grid. Method name - \"Brownian_motion()\".\n",
        "\n",
        "2.   Calculate the Stock prices for the corresponding time grid. For the Black-Scholes by default we calculate the stock price under the risk neutral measure Q. However, mean return of the risky asset can be used as input. Method name - \"Stock_price()\".\n",
        "\n",
        "3.   Calculate d1 and d2 parameters required for the formula. Method name - \"d1_d2_parameters()\".\n",
        "\n",
        "4.   Calculate the price of the call/put option using the Black-Scholes formula. Method name - option_pricing().\n",
        "\n",
        "5.   Calculate the delta of the put/call option using the exact formula and/or using the different methods such as \"Bump and reprice with common numbers\", \"Path-wise method\" and \"Likelihood ratio method\". Small change \"h\" that is used for the derivative approximation can be picked manually. As well as the number of Monte-Carlo simulation. (The more the better). Method name for exact calculation - \"delta()\" and for the approximations - \"delta_approximate(h, m)\".\n",
        "\n",
        "6.   Since we use the self financing portfolio we can derive sample paths of the stock and money market account positions. Method name - \"self_financing_sample_path()\" .\n",
        "\n",
        "7.   Self financing delta hedging of the portfolio. Method name - \"hedge(trading_step, number of options, number of hedging simulations, initial bond price, option type put or call)\".\n",
        "\n"
      ],
      "metadata": {
        "id": "XCNNCSN8eWpv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Black_Scholes:\n",
        "    \n",
        "    def __init__(self, T_, mu_, sigma_, s0_, r_, K_, step_size_):\n",
        "        \n",
        "        self.T = T_\n",
        "        self.mu = mu_\n",
        "        self.sigma = sigma_\n",
        "        self.s0 = s0_\n",
        "        self.r = r_\n",
        "        self.K = K_\n",
        "        self.step_size = step_size_\n",
        "        self.W = None\n",
        "        \n",
        "    def Brownian_motion(self, n, hedging = False):\n",
        "        \n",
        "        self.grid = np.arange(0, T + self.step_size, self.step_size)\n",
        "        self.grid_modified = np.flip(self.grid[1:])\n",
        "        if n != 1:\n",
        "\n",
        "            increments = np.sqrt(self.step_size) * norm.rvs(size = [n, len(self.grid) - 1])\n",
        "            W_holder = np.cumsum(increments, axis = 1)\n",
        "            W_ = [[0]*len(self.grid)]*n\n",
        "            for i in range(0, n):\n",
        "                W_[i] = np.insert(W_holder[i], 0, 0)\n",
        "\n",
        "        else:\n",
        "\n",
        "            increments = np.sqrt(self.step_size) * norm.rvs(size = len(self.grid) - 1)\n",
        "            W_ = np.cumsum(increments)\n",
        "            W_ = np.insert(W_, 0, 0)\n",
        "            \n",
        "        if hedging:\n",
        "\n",
        "            self.W_hedging = W_\n",
        "            return self.W_hedging, self.grid, self.grid_modified\n",
        "\n",
        "        else: \n",
        "\n",
        "            self.W = W_\n",
        "        \n",
        "    def get_Brownian_motion(self):\n",
        "\n",
        "        return self.W\n",
        "    \n",
        "    def Stock_price(self, parameter, hedging = False):\n",
        "\n",
        "        if hedging:\n",
        "\n",
        "            S_ = self.s0 * np.exp((parameter - 0.5 * self.sigma ** 2) * self.grid + np.multiply(self.sigma, self.W_hedging)) #if parameter = r, then risk neutral measure\n",
        "            self.S_hedging = S_\n",
        "            return self.S_hedging\n",
        "\n",
        "        else: \n",
        "\n",
        "            S_ = self.s0 * np.exp((parameter - 0.5 * self.sigma ** 2) * self.grid + np.multiply(self.sigma, self.W))\n",
        "            self.S = S_\n",
        "\n",
        "    def get_Stock_price(self):\n",
        "\n",
        "        return self.S\n",
        "\n",
        "    def euler_approximation(self, Euler_step_size):\n",
        "\n",
        "        refinement = np.arange(0, len(self.grid), Euler_step_size / self.step_size)\n",
        "\n",
        "        self.euler_grid = [0]\n",
        "\n",
        "        self.S_euler = np.zeros((len(refinement),))\n",
        "\n",
        "        self.S_euler[0] = self.s0\n",
        "\n",
        "        for t in range(0, len(refinement)-1):\n",
        "\n",
        "            self.euler_grid.append(self.grid[int(refinement[t+1])])\n",
        "\n",
        "            self.S_euler[t+1] = self.S_euler[t] + self.r*self.S_euler[t] * Euler_step_size + self.sigma*self.S_euler[t]*(self.W[int(refinement[t+1])]-self.W[int(refinement[t])])\n",
        "\n",
        "\n",
        "    def get_euler_approximation(self):\n",
        "\n",
        "        return self.S_euler, self.euler_grid, self.grid\n",
        "\n",
        "    def d1_d2_parameters(self, hedging = False):\n",
        "\n",
        "        def parameters(self, stock):\n",
        "\n",
        "            if np.ndim(stock) != 1:\n",
        "\n",
        "                d1_ = (np.log(stock[:,:len(self.grid_modified)]/self.K) + (self.r + 0.5*self.sigma**2)*(self.grid_modified)) / (self.sigma*np.sqrt(self.grid_modified))\n",
        "                d2_ = d1_ - self.sigma*np.sqrt(self.grid_modified)\n",
        "\n",
        "            else: \n",
        "\n",
        "                d1_ = (np.log(stock[:len(stock)-1]/self.K) + (self.r + 0.5*self.sigma**2)*(self.grid_modified)) / (self.sigma*np.sqrt(self.grid_modified))\n",
        "                d2_ = d1_ - self.sigma*np.sqrt(self.grid_modified)\n",
        "\n",
        "            return d1_,d2_\n",
        "\n",
        "        if hedging:\n",
        "            self.d1_hedging, self.d2_hedging = parameters(self,self.S_hedging)\n",
        "            return self.d1_hedging, self.d2_hedging\n",
        "\n",
        "        else: \n",
        "            self.d1, self.d2 = parameters(self,self.S)\n",
        "\n",
        "\n",
        "    def get_d1_d2_parameters(self):\n",
        "\n",
        "        return self.d1,self.d2\n",
        "\n",
        "\n",
        "    def option_pricing(self, hedging = False):\n",
        "    \n",
        "        def opt(self,d1,d2,stock):\n",
        "            if np.ndim(stock) == 1:\n",
        "\n",
        "                P_ = self.K * np.multiply(np.exp(-self.r*self.grid_modified),norm.cdf(-d2)) - np.multiply(stock[:len(stock)-1],norm.cdf(-d1))\n",
        "                C_ = stock[:len(stock)-1]*norm.cdf(d1,0,1) - self.K*np.exp(-self.r*self.grid_modified)*norm.cdf(d2,0,1)\n",
        "            else: \n",
        "\n",
        "                P_ = self.K * np.multiply(np.exp(-self.r*self.grid_modified),norm.cdf(-d2)) - np.multiply(stock[:,:len(self.grid_modified)],norm.cdf(-d1))\n",
        "                C_ = stock[:,:len(self.grid_modified)]*norm.cdf(d1,0,1) - self.K*np.exp(-self.r*self.grid_modified)*norm.cdf(d2,0,1)\n",
        "\n",
        "            return P_,C_\n",
        "\n",
        "        if hedging:\n",
        "            self.P_hedging,self.C_hedging = opt(self,self.d1_hedging,self.d2_hedging,self.S_hedging)\n",
        "            return self.P_hedging,self.C_hedging\n",
        "        else:\n",
        "            self.P,self.C = opt(self,self.d1,self.d2,self.S)\n",
        "\n",
        "    def get_option_price(self,time):\n",
        "        \n",
        "        if len(np.shape(self.W)) == 1:\n",
        "            \n",
        "            return \"Put option price = {}, Call option price = {}\".format(self.P[time],self.C[time])\n",
        "        \n",
        "        else:\n",
        "            return \"Put option price = {}, Call option price = {}\".format(np.mean(self.P[:,time]),np.mean(self.C[:,time]))\n",
        "\n",
        "    def delta(self, hedging = False):\n",
        "        \n",
        "        if hedging: \n",
        "\n",
        "            self.delta_put_hedging = -norm.cdf(-self.d1_hedging)\n",
        "            self.delta_call_hedging = norm.cdf(self.d1_hedging)\n",
        "            return self.delta_put_hedging,self.delta_call_hedging\n",
        "        else:\n",
        "\n",
        "            self.delta_put = -norm.cdf(-self.d1)\n",
        "            self.delta_call = norm.cdf(self.d1)\n",
        "\n",
        "        \n",
        "    \n",
        "    def get_delta(self,time):\n",
        "        \n",
        "        if len(np.shape(self.W)) == 1:\n",
        "            \n",
        "            return \"Delta of the put option: {}, delta of the call option: {}\".format(self.delta_put[time], self.delta_call[time])\n",
        "        \n",
        "        else:\n",
        "            \n",
        "            return \"Delta of the put option: {}, delta of the call option: {}\".format(np.mean(self.delta_put[:,time]), np.mean(self.delta_call[:,time]))\n",
        "\n",
        "    def delta_approximate(self, h, m):\n",
        "        \n",
        "        # Delta approximation for time = 0.\n",
        "        \n",
        "        # 1.Bump and reprice method with common numbers\n",
        "         \n",
        "        W_T = np.sqrt(T)*norm.rvs(size = m, random_state=None)\n",
        "        S_T = self.s0*np.exp((self.r-0.5*self.sigma**2)*self.T+self.sigma*W_T)\n",
        "        S_T_h = (self.s0+h)*np.exp((self.r-0.5*self.sigma**2)*self.T+self.sigma*W_T)\n",
        "        \n",
        "        # Put\n",
        "        P_T = np.clip(self.K-S_T, 0, np.inf)\n",
        "        P_T_h = np.clip(self.K-S_T_h, 0, np.inf)\n",
        "        proxyprice = np.exp(-self.r*self.T)*np.mean(P_T)\n",
        "        proxyprice_h = np.exp(-self.r*self.T)*np.mean(P_T_h)\n",
        "        self.delta_put_BR_C = (proxyprice_h - proxyprice)/h\n",
        "        \n",
        "        # Call \n",
        "        C_T = np.clip(S_T-self.K, 0, np.inf)\n",
        "        C_T_h = np.clip(S_T_h-self.K, 0, np.inf)\n",
        "        proxyprice_c = np.exp(-self.r*self.T)*np.mean(C_T)\n",
        "        proxyprice_h_c = np.exp(-self.r*self.T)*np.mean(C_T_h)\n",
        "        self.delta_call_BR_C = (proxyprice_h_c - proxyprice_c)/h\n",
        "        \n",
        "        \n",
        "        \n",
        "        # 2.Path-wise method\n",
        "    \n",
        "        S_T = self.s0 * np.exp((self.r-0.5*self.sigma**2) + self.sigma * np.sqrt(self.T) * norm.rvs(size = m, random_state=None))\n",
        "        \n",
        "        # Put \n",
        "        input_delta_pathwise = -np.exp((self.r-0.5*self.sigma**2)*self.T+self.sigma*np.sqrt(self.T)*norm.rvs(0,1))*np.where(S_T < self.K, 1, 0)\n",
        "        self.delta_put_pathwise = np.exp(-self.r*self.T)*np.mean(input_delta_pathwise)\n",
        "        \n",
        "        # Call \n",
        "        input_delta_pathwise_call = np.exp((self.r-0.5*self.sigma**2)*self.T+self.sigma*np.sqrt(self.T)*norm.rvs(0,1))*np.where(S_T > self.K, 1, 0)\n",
        "        self.delta_call_pathwise = np.exp(-self.r*self.T)*np.mean(input_delta_pathwise_call)\n",
        "\n",
        "\n",
        "    \n",
        "        # 3.Likelihood ratio method\n",
        "        \n",
        "        delta_all_LRM = [0]*m\n",
        "        delta_all_LRM_call = [0]*m\n",
        "        \n",
        "        for i in range(0, m-1):\n",
        "\n",
        "            S_T = self.s0*np.exp((self.r-0.5*self.sigma**2)+self.sigma*np.sqrt(self.T)*norm.rvs())\n",
        "\n",
        "            delta_all_LRM[i] = np.clip(self.K-S_T, 0, np.inf)*(np.log(S_T/self.s0)-(self.r-0.5*self.sigma**2)*self.T)/((self.sigma**2)*self.T*self.s0)\n",
        "            delta_all_LRM_call[i] = np.clip(S_T-K, 0, np.inf)*(np.log(S_T/s0)-(r-0.5*sigma**2)*T)/((sigma**2)*T*s0)\n",
        "            \n",
        "        self.delta_put_LRM = np.exp(-self.r*self.T)*np.mean(delta_all_LRM)\n",
        "        self.delta_call_LRM = np.exp(-r*T)*np.mean(delta_all_LRM_call)\n",
        "       \n",
        "    def get_delta_approximate(self,option):\n",
        "        \n",
        "        if option.lower() == \"put\":\n",
        "        \n",
        "            return \"Put option => Bump and reprice with common numbers: {} \\nPath-wise method: {} \\nLikelihood ratio method: {}\".format(self.delta_put_BR_C,self.delta_put_pathwise,self.delta_put_LRM)\n",
        "        \n",
        "        elif option.lower() == \"call\":\n",
        "            \n",
        "            return \"Call option => Bump and reprice with common numbers: {} \\nPath-wise method: {} \\nLikelihood ratio method: {}\".format(self.delta_call_BR_C,self.delta_call_pathwise,self.delta_call_LRM)\n",
        "        \n",
        "    def self_financing_sample_path(self):\n",
        "        \n",
        "        self.phi_sf = self.delta_put\n",
        "        self.B = np.exp(self.r * self.grid)\n",
        "        self.psi_sf = (self.P - self.phi_sf * self.S[:len(self.S)-1]) / self.B[:len(self.B)-1]\n",
        "        self.Value_replicating_portfolio_sf = self.phi_sf * self.S[:len(self.S)-1] + self.psi_sf * self.B[:len(self.B)-1]\n",
        "        \n",
        "    def get_self_financing_sample_path(self):\n",
        "        \n",
        "        return self.phi_sf,self.psi_sf,self.Value_replicating_portfolio_sf\n",
        "      \n",
        "    \n",
        "    def hedge(self, trading_step_, option_number_, N_, B0_,option_type):\n",
        "\n",
        "        self.trading_step = trading_step_\n",
        "        self.option_number = option_number_\n",
        "        self.N = N_\n",
        "        self.B0 = B0_\n",
        "        hedging = True\n",
        "\n",
        "        def trade(self, trade_grid,delta,option):\n",
        "\n",
        "            self.psi = np.zeros([self.N, len(trade_grid)]) \n",
        "            self.phi = np.zeros([self.N, len(trade_grid)]) \n",
        "            self.phi[:,0] = -1 * (self.option_number) * delta[:,0]\n",
        "            available = (-self.option_number)*option[:,0]\n",
        "            self.psi[:,0] = (available - self.phi[:,0]*self.S_hedging[:,0]) / self.B[0]\n",
        "\n",
        "            for i in range(0,self.N-1):\n",
        "                \n",
        "                for t in range(1, len(trade_grid)): \n",
        "                    \n",
        "                    trade_time = np.where(self.grid == trade_grid[t])[0][0]\n",
        "                    delta_t = delta[i,trade_time]\n",
        "                    available = self.phi[i,t-1]*self.S_hedging[i,trade_time] + self.psi[i,t-1]*self.B[trade_time]\n",
        "                    self.phi[i,t] = (-1)*(self.option_number)* delta_t\n",
        "                    self.psi[i,t] = (available - self.phi[i,t]*self.S_hedging[i,trade_time]) / self.B[trade_time]\n",
        "\n",
        "\n",
        "        W,self.grid,self.grid_modified = Black_Scholes.Brownian_motion(self,self.N,hedging)\n",
        "        self.S_hedging = Black_Scholes.Stock_price(self, self.r,hedging)\n",
        "        self.B = self.B0*np.exp(self.r * self.grid)\n",
        "        trade_grid = np.arange(0, self.T, self.trading_step)\n",
        "        d1, d2 = Black_Scholes.d1_d2_parameters(self,hedging)\n",
        "        P, C = Black_Scholes.option_pricing(self,hedging)\n",
        "        delta_put, delta_call = Black_Scholes.delta(self,hedging)\n",
        "        \n",
        "        if option_type.lower() == \"put\":\n",
        "            trade(self, trade_grid, delta_put, P)\n",
        "        else:\n",
        "            trade(self, trade_grid, delta_call, C)\n",
        "\n",
        "\n",
        "    def performance(self):\n",
        "        \n",
        "        self.V_T = self.phi[:,-1]*self.S_hedging[:,-1] + self.psi[:,-1]*self.B[-1]\n",
        "        self.C_T = (-self.option_number)*np.clip(self.K-self.S_hedging[:,-1], 0, np.inf)\n",
        "        self.Liability = self.V_T - self.C_T\n",
        "        self.mean_liability = np.mean(self.Liability)\n",
        "        self.std_liability = np.std(self.Liability)\n",
        "\n",
        "        output = \"Mean liability = {} \\nStandard deviation of the liability = {}\".format(self.mean_liability,self.std_liability)\n",
        "        print(output)\n",
        "\n",
        "        return self.V_T,self.C_T\n",
        "\n"
      ],
      "metadata": {
        "id": "_HUfi3kbRHtb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Initialize the parameters."
      ],
      "metadata": {
        "id": "H5MvQbDLx6hz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = 1               # Time of option expiration\n",
        "step_size = 0.001   # Step size in the time grid\n",
        "mu = 0.6            # The drift rate of the risky asset S\n",
        "sigma = 0.2         # standard deviation of the risky asset S\n",
        "K = 90              # Strike price\n",
        "s0 = 100            # Initial price of the risky asset S\n",
        "r = 0.01            # Interest rate           # Initial Bond price           # Number of simulations"
      ],
      "metadata": {
        "id": "lfgyCpmhTjYu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, generate all the necessary information by calling the following functions."
      ],
      "metadata": {
        "id": "yExa-tZpx-Xr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "\n",
        "Stock_1 = Black_Scholes(T, mu, sigma, s0, r, K, step_size)\n",
        "\n",
        "#############################\n",
        "Number_of_simulations = 1\n",
        "#############################\n",
        "\n",
        "Stock_1.Brownian_motion(Number_of_simulations)\n",
        "\n",
        "Stock_1.Stock_price(r)\n",
        "\n",
        "Stock_1.d1_d2_parameters()\n",
        "\n",
        "Stock_1.option_pricing()\n",
        "\n",
        "Stock_1.delta()\n",
        "\n",
        "############################\n",
        "small_change = 0.001 # Small change for the derivative approximation \n",
        "MC_simulations = 10000 # Number of Monte Carlo simulations for the approximation of the delta\n",
        "############################\n",
        "\n",
        "Stock_1.delta_approximate(small_change, MC_simulations)\n",
        "\n",
        "Stock_1.self_financing_sample_path()\n"
      ],
      "metadata": {
        "id": "oOaeuMiuRSa5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(Stock_1.get_Brownian_motion())\n",
        "plt.title('Brownian motion sample path')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "URYDBhz9o8hL",
        "outputId": "a9997cb1-0aae-4d2b-8492-d6ac5885b087"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(Stock_1.get_Stock_price())\n",
        "plt.title('Stock price sample path')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "BMpQBEu9o8dd",
        "outputId": "674dccfb-99b2-4be4-b3c0-e9e93b2f0c83"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following next 2 cells, perform the Euler approximation of the Stock price under the neutral measure Q. "
      ],
      "metadata": {
        "id": "yuhgIvKeyU5H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "euler_step = 0.1\n",
        "Stock_1.euler_approximation(euler_step) "
      ],
      "metadata": {
        "id": "08uQjonvuQzO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "S_euler, euler_grid, grid = Stock_1.get_euler_approximation()\n",
        "plt.plot(grid, Stock_1.get_Stock_price(), label = \"Exact simulation\")\n",
        "plt.plot(euler_grid, S_euler, label = \"Euler approximation\")\n",
        "plt.title('Euler Approximation with Euler step = {}'.format(euler_step))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "IrqMD9SGucl9",
        "outputId": "60e5f60f-e88c-4b66-db08-d2c0f8d45c90"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Euler Approximation with Euler step = 0.1')"
            ]
          },
          "metadata": {},
          "execution_count": 41
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(Stock_1.get_delta(0))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u43z2QHao8aE",
        "outputId": "d86da266-91e6-45d0-82d9-70bcdbdfc9ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta of the put option: -0.24926561103492134, delta of the call option: 0.7507343889650786\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(Stock_1.get_delta_approximate('Put'))\n",
        "\n",
        "print(\"\\n\" + Stock_1.get_delta_approximate('call'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2MptCNN3o8Rz",
        "outputId": "71a9cf98-72f1-406a-e835-0b8b0bb0f5d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Put option => Bump and reprice with common numbers: -0.2426280785559065 \n",
            "Path-wise method: -0.30062137661624383 \n",
            "Likelihood ratio method: -0.24710283145656006\n",
            "\n",
            "Call option => Bump and reprice with common numbers: 0.7595539953957342 \n",
            "Path-wise method: 0.575266067408347 \n",
            "Likelihood ratio method: 0.7421444275936804\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stock_position, money_market_position, Value_replicating_portfolio = Stock_1.get_self_financing_sample_path()\n",
        "\n",
        "figure, axis = plt.subplots(2, 2)\n",
        "  \n",
        "axis[0, 0].plot(stock_position)\n",
        "axis[0, 0].set_title(\"Stock position\")\n",
        "\n",
        "axis[0, 1].plot(money_market_position)\n",
        "axis[0, 1].set_title(\"Money market account position\")\n",
        "\n",
        "axis[1, 0].plot(Value_replicating_portfolio)\n",
        "axis[1, 0].set_title(\"Value replicating portfolio\")\n",
        "\n",
        "axis[1, 1].plot(Stock_1.get_Stock_price())\n",
        "axis[1, 1].set_title(\"Stock price\")\n",
        "\n",
        "figure.tight_layout(pad = 2.0)\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "PGw2ujvoo8Nx",
        "outputId": "316d02c4-68fa-4d47-a458-fa391c9ca0bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Delta hedging the portfolio.\n",
        "\n",
        "1.   N - number of hedging simulations \n",
        "2.   trading_step - readjustments at a time grid with stepsize \n",
        "\n"
      ],
      "metadata": {
        "id": "cNbzbIU6ye-i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%capture\n",
        "############################\n",
        "N = 1000 \n",
        "trading_step = 0.002 \n",
        "number_of_options = -1000\n",
        "B0 = 1\n",
        "option_type = \"Put\"\n",
        "############################\n",
        "\n",
        "Stock_1.hedge(trading_step, number_of_options, N, B0, option_type)\n",
        "Stock_1.performance()"
      ],
      "metadata": {
        "id": "4YDUS1rAkygY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Value_portfolio, Cost = Stock_1.performance()\n",
        "\n",
        "\n",
        "figure, axis = plt.subplots(1, 2)\n",
        "  \n",
        "axis[0].hist(Cost - Value_portfolio,bins = 100)\n",
        "axis[0].set_title(\"Hedge error (C_T - V_T)\")\n",
        "\n",
        "axis[1].scatter(Cost, Value_portfolio)\n",
        "axis[1].set_title(\"Scatter plot Cost vs Value of the portoflio\")\n",
        "\n",
        "figure.tight_layout(pad = 1.5)\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 323
        },
        "id": "ER39FYKJnV7G",
        "outputId": "4ca21dab-938e-4047-e444-fb58cc202e35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean liability = -1.875445411817578 \n",
            "Standard deviation of the liability = 282.75674967670415\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "shBCkv8L09dH"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}