BS and MC methods for Option Pricing.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/worldart/worldart_jupyternotebook/blob/main/BS%20and%20MC%20methods%20for%20Option%20Pricing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dc149cf0-ca4d-4b31-94aa-5296998f3dc2",
      "metadata": {
        "id": "dc149cf0-ca4d-4b31-94aa-5296998f3dc2"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy.stats import norm\n",
        "import scipy.stats as ss\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "23295712-7c88-4efa-95d9-0e92b3de7286",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "23295712-7c88-4efa-95d9-0e92b3de7286",
        "outputId": "40b3b29d-e38a-49de-95e2-0623190f316b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "European Call Option Price: 4.61\n",
            "European Put Option Price: 3.37\n"
          ]
        }
      ],
      "source": [
        "#Price European call and put options using a Black-Scholes solution:\n",
        "\n",
        "# Given parameters\n",
        "S0 = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "\n",
        "def black_scholes(S, K, r, sigma, T):\n",
        "    d1 = (np.log(S/K) + (r + sigma**2/2)*T) / (sigma*np.sqrt(T))\n",
        "    d2 = d1 - sigma*np.sqrt(T)\n",
        "\n",
        "    call_price = S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)\n",
        "    put_price = K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)\n",
        "\n",
        "    return call_price, put_price\n",
        "\n",
        "\n",
        "# Calculate call and put option prices\n",
        "call_price, put_price = black_scholes(S0, K, r, sigma, T)\n",
        "\n",
        "print(f\"European Call Option Price: {call_price:.2f}\")\n",
        "print(f\"European Put Option Price: {put_price:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e78b7813-cb05-40ba-80f0-22837171fcaf",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e78b7813-cb05-40ba-80f0-22837171fcaf",
        "outputId": "21f96bd0-2350-4e15-da51-a08b0e2c0978"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta = 0.57\n",
            "Gamma = 0.04\n",
            "Vega = 19.64\n",
            "Theta = -10.47\n",
            "Rho = 13.08\n"
          ]
        }
      ],
      "source": [
        "# Analyze the Greeks for input in Black-Scholes formula CALL Option:\n",
        "\n",
        "# Given parameters\n",
        "S = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "vol = 0.20\n",
        "option_type = \"C\"  # for the put insert 'P'\n",
        "\n",
        "# dividend yield assumed to be 0\n",
        "\n",
        "# Compute d1 and d2\n",
        "d1 = (np.log(S / K) + (r + 0.5 * vol**2) * T) / (vol * np.sqrt(T))\n",
        "d2 = d1 - vol * np.sqrt(T)\n",
        "\n",
        "if option_type in [\"C\", \"P\"]:\n",
        "    if option_type in [\"C\"]:\n",
        "        Opt_Price = S * ss.norm.cdf(d1) - K * np.exp(-r * T) * ss.norm.cdf(d2)\n",
        "        Delta = ss.norm.cdf(d1)\n",
        "        Gamma = ss.norm.pdf(d1) / (S * vol * np.sqrt(T))\n",
        "        Vega = S * ss.norm.pdf(d1) * np.sqrt(T)\n",
        "        Theta = -(S * ss.norm.pdf(d1) * vol) / (2 * np.sqrt(T)) - r * K * np.exp(\n",
        "            -r * T\n",
        "        ) * ss.norm.cdf(d2)\n",
        "        Rho = K * T * np.exp(-r * T) * ss.norm.cdf(d2)\n",
        "    else:\n",
        "        Opt_Price = K * np.exp(-r * T) * ss.norm.cdf(-d2) - S * ss.norm.cdf(-d1)\n",
        "        Delta = -ss.norm.cdf(-d1)\n",
        "        Gamma = ss.norm.pdf(d1) / (S * vol * np.sqrt(T))\n",
        "        Vega = S * ss.norm.pdf(d1) * np.sqrt(T)\n",
        "        Theta = -(S * ss.norm.pdf(d1) * vol) / (2 * np.sqrt(T)) + r * K * np.exp(\n",
        "            -r * T\n",
        "        ) * ss.norm.cdf(-d2)\n",
        "        Rho = -K * T * np.exp(-r * T) * ss.norm.cdf(-d2)\n",
        "else:\n",
        "    Opt_Price = \"Error: option type incorrect. Choose P for a put option or C for a call option.\"\n",
        "\n",
        "print(f\"Delta = {Delta:.2f}\")\n",
        "print(f\"Gamma = {Gamma:.2f}\")\n",
        "print(f\"Vega = {Vega:.2f}\")\n",
        "print(f\"Theta = {Theta:.2f}\")\n",
        "print(f\"Rho = {Rho:.2f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e9a2ce69-79e8-4183-b21b-7767c0ee9696",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e9a2ce69-79e8-4183-b21b-7767c0ee9696",
        "outputId": "55006c52-3335-46f0-d5ce-799a565ec5c9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta = -0.43\n",
            "Gamma = 0.04\n",
            "Vega = 19.64\n",
            "Theta = -5.54\n",
            "Rho = -11.61\n"
          ]
        }
      ],
      "source": [
        "# Analyze the Greeks for input in Black-Scholes formula PUT Option:\n",
        "\n",
        "# Given parameters\n",
        "S = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "vol = 0.20\n",
        "option_type = \"P\"\n",
        "\n",
        "# dividend yield assumed to be 0\n",
        "\n",
        "# Compute d1 and d2\n",
        "d1 = (np.log(S / K) + (r + 0.5 * vol**2) * T) / (vol * np.sqrt(T))\n",
        "d2 = d1 - vol * np.sqrt(T)\n",
        "\n",
        "if option_type in [\"C\", \"P\"]:\n",
        "    if option_type in [\"C\"]:\n",
        "        Opt_Price = S * ss.norm.cdf(d1) - K * np.exp(-r * T) * ss.norm.cdf(d2)\n",
        "        Delta = ss.norm.cdf(d1)\n",
        "        Gamma = ss.norm.pdf(d1) / (S * vol * np.sqrt(T))\n",
        "        Vega = S * ss.norm.pdf(d1) * np.sqrt(T)\n",
        "        Theta = -(S * ss.norm.pdf(d1) * vol) / (2 * np.sqrt(T)) - r * K * np.exp(\n",
        "            -r * T\n",
        "        ) * ss.norm.cdf(d2)\n",
        "        Rho = K * T * np.exp(-r * T) * ss.norm.cdf(d2)\n",
        "    else:\n",
        "        Opt_Price = K * np.exp(-r * T) * ss.norm.cdf(-d2) - S * ss.norm.cdf(-d1)\n",
        "        Delta = -ss.norm.cdf(-d1)\n",
        "        Gamma = ss.norm.pdf(d1) / (S * vol * np.sqrt(T))\n",
        "        Vega = S * ss.norm.pdf(d1) * np.sqrt(T)\n",
        "        Theta = -(S * ss.norm.pdf(d1) * vol) / (2 * np.sqrt(T)) + r * K * np.exp(\n",
        "            -r * T\n",
        "        ) * ss.norm.cdf(-d2)\n",
        "        Rho = -K * T * np.exp(-r * T) * ss.norm.cdf(-d2)\n",
        "else:\n",
        "    Opt_Price = \"Error: option type incorrect. Choose P for a put option or C for a call option.\"\n",
        "\n",
        "print(f\"Delta = {Delta:.2f}\")\n",
        "print(f\"Gamma = {Gamma:.2f}\")\n",
        "print(f\"Vega = {Vega:.2f}\")\n",
        "print(f\"Theta = {Theta:.2f}\")\n",
        "print(f\"Rho = {Rho:.2f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4a642434-839e-41d1-b497-4563a4334dbf",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4a642434-839e-41d1-b497-4563a4334dbf",
        "outputId": "48768d9f-e49c-4606-e7b6-a27db3897307"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "European Call Option Price: 4.63\n",
            "European Put Option Price: 3.39\n"
          ]
        }
      ],
      "source": [
        "#Price European call and put options using Monte-Carlo methods under a general GBM equation with daily time-steps in the simulations:\n",
        "\n",
        "# Given parameters\n",
        "S0 = 100\n",
        "K = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "num_simulations = 100000\n",
        "time_steps = 90\n",
        "\n",
        "\n",
        "def monte_carlo_option_pricing(S0, K, r, sigma, T, num_simulations, time_steps):\n",
        "    dt = T / time_steps\n",
        "    Z = np.random.randn(num_simulations, time_steps)\n",
        "\n",
        "    # Step 1: Simulate stock price paths according to SDE dynamics.\n",
        "    S = np.zeros((num_simulations, time_steps + 1))\n",
        "    S[:, 0] = S0\n",
        "    for i in range(1, time_steps + 1):\n",
        "        S[:, i] = S[:, i-1] * np.exp((r - 0.5*sigma**2)*dt + sigma*np.sqrt(dt)*Z[:, i-1])\n",
        "\n",
        "    # Step 2: Calculate option payoffs\n",
        "    call_payoffs = np.maximum(S[:, -1] - K, 0)\n",
        "    put_payoffs = np.maximum(K - S[:, -1], 0)\n",
        "\n",
        "    # Step 3: Obtain the average expected payoff at maturity, T and will discount the average expected payoff to time t. As explained previously, we will use the T = T - t = 3/12 = 0.25 as parameter.\n",
        "    call_price = np.mean(call_payoffs) * np.exp(-r*T)\n",
        "    put_price = np.mean(put_payoffs) * np.exp(-r*T)\n",
        "\n",
        "    return call_price, put_price\n",
        "\n",
        "\n",
        "# Calculate call and put option prices\n",
        "call_price, put_price = monte_carlo_option_pricing(S0, K, r, sigma, T, num_simulations, time_steps)\n",
        "\n",
        "print(f\"European Call Option Price: {call_price:.2f}\")\n",
        "print(f\"European Put Option Price: {put_price:.2f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5fb0549a-df84-420d-9a88-97e889ff4bda",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5fb0549a-df84-420d-9a88-97e889ff4bda",
        "outputId": "cd0ac9ca-ffed-49a1-f868-62d82c55c36f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta = 0.57\n",
            "Gamma = 0.09\n",
            "Vega = 19.62\n",
            "Theta = 23736.54\n",
            "Rho = -1.15\n"
          ]
        }
      ],
      "source": [
        "# Analyze the Greeks for a European call option using Monte Carlo methods under a general Geometric Brownian Motion (GBM) with daily time steps\n",
        "\n",
        "# Given parameters\n",
        "S = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "vol = 0.20\n",
        "option_type = \"C\"  # \"P\" for put, \"C\" for call\n",
        "\n",
        "# Simulation parameters\n",
        "n_simulations = 100000  # Number of simulations\n",
        "n_steps = int(252 * T)  # Number of daily time steps (252 trading days per year)\n",
        "dt = T / n_steps  # Time step\n",
        "\n",
        "# Monte Carlo simulation for asset paths\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))\n",
        "S_t = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t[:, 0] = S\n",
        "\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t[:, t] = S_t[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate option payoff at maturity\n",
        "if option_type == \"P\":\n",
        "    payoffs = np.maximum(K - S_t[:, -1], 0)\n",
        "elif option_type == \"C\":\n",
        "    payoffs = np.maximum(S_t[:, -1] - K, 0)\n",
        "else:\n",
        "    raise ValueError(\"Error: option type incorrect. Choose 'P' for a put option or 'C' for a call option.\")\n",
        "\n",
        "# Discounted expected payoff\n",
        "Opt_Price = np.exp(-r * T) * np.mean(payoffs)\n",
        "\n",
        "# Delta approximation\n",
        "S_up = S + 1e-4  # Slightly increase initial stock price\n",
        "S_down = S - 1e-4  # Slightly decrease initial stock price\n",
        "\n",
        "# Simulate paths for S_up\n",
        "S_t_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_up[:, 0] = S_up\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_up[:, t] = S_t_up[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for S_down\n",
        "S_t_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_down[:, 0] = S_down\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_down[:, t] = S_t_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for S_up and S_down\n",
        "if option_type == \"P\":\n",
        "    payoffs_up = np.maximum(K - S_t_up[:, -1], 0)\n",
        "    payoffs_down = np.maximum(K - S_t_down[:, -1], 0)\n",
        "elif option_type == \"C\":\n",
        "    payoffs_up = np.maximum(S_t_up[:, -1] - K, 0)\n",
        "    payoffs_down = np.maximum(S_t_down[:, -1] - K, 0)\n",
        "\n",
        "Opt_Price_up = np.exp(-r * T) * np.mean(payoffs_up)\n",
        "Opt_Price_down = np.exp(-r * T) * np.mean(payoffs_down)\n",
        "\n",
        "Delta = (Opt_Price_up - Opt_Price_down) / (2 * 1e-4)\n",
        "\n",
        "# Gamma approximation\n",
        "Gamma = (Opt_Price_up - 2 * Opt_Price + Opt_Price_down) / (1e-4)**2\n",
        "\n",
        "# Vega approximation\n",
        "vol_up = vol + 1e-4\n",
        "vol_down = vol - 1e-4\n",
        "\n",
        "# Simulate paths for vol_up\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))  # Re-generate noise\n",
        "S_t_vol_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_up[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_up[:, t] = S_t_vol_up[:, t-1] * np.exp((r - 0.5 * vol_up**2) * dt + vol_up * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for vol_down\n",
        "S_t_vol_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_down[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_down[:, t] = S_t_vol_down[:, t-1] * np.exp((r - 0.5 * vol_down**2) * dt + vol_down * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for vol_up and vol_down\n",
        "payoffs_vol_up = np.maximum(K - S_t_vol_up[:, -1], 0)\n",
        "payoffs_vol_down = np.maximum(K - S_t_vol_down[:, -1], 0)\n",
        "\n",
        "Opt_Price_vol_up = np.exp(-r * T) * np.mean(payoffs_vol_up)\n",
        "Opt_Price_vol_down = np.exp(-r * T) * np.mean(payoffs_vol_down)\n",
        "\n",
        "Vega = (Opt_Price_vol_up - Opt_Price_vol_down) / (2 * 1e-4)\n",
        "\n",
        "# Theta approximation\n",
        "T_down = T - 1 / 252  # Reduce maturity by one day\n",
        "\n",
        "# Simulate paths for T_down\n",
        "S_t_T_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_T_down[:, 0] = S\n",
        "for t in range(1, n_steps):\n",
        "    S_t_T_down[:, t] = S_t_T_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "payoffs_T_down = np.maximum(K - S_t_T_down[:, -1], 0)\n",
        "Opt_Price_T_down = np.exp(-r * T_down) * np.mean(payoffs_T_down)\n",
        "\n",
        "Theta = (Opt_Price_T_down - Opt_Price) / (1 / 252)\n",
        "\n",
        "# Rho approximation\n",
        "r_up = r + 1e-4\n",
        "r_down = r - 1e-4\n",
        "\n",
        "# Simulate paths for r_up and r_down\n",
        "Opt_Price_r_up = np.exp(-r_up * T) * np.mean(payoffs)\n",
        "Opt_Price_r_down = np.exp(-r_down * T) * np.mean(payoffs)\n",
        "\n",
        "Rho = (Opt_Price_r_up - Opt_Price_r_down) / (2 * 1e-4)\n",
        "\n",
        "print(f\"Delta = {Delta:.2f}\")\n",
        "print(f\"Gamma = {Gamma:.2f}\")\n",
        "print(f\"Vega = {Vega:.2f}\")\n",
        "print(f\"Theta = {Theta:.2f}\")\n",
        "print(f\"Rho = {Rho:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "32e16215-5ffb-4902-b5aa-b652ac38ed68",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "32e16215-5ffb-4902-b5aa-b652ac38ed68",
        "outputId": "383fc7d7-1d5f-4787-cc3f-eaad33a2b39a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta = -0.43\n",
            "Gamma = 0.09\n",
            "Vega = 19.62\n",
            "Theta = 24043.99\n",
            "Rho = -0.84\n"
          ]
        }
      ],
      "source": [
        "# Analyze the Greeks for a European put option using Monte Carlo methods under a general Geometric Brownian Motion (GBM) with daily time steps\n",
        "\n",
        "# Given parameters\n",
        "S = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "vol = 0.20\n",
        "option_type = \"P\"  # \"P\" for put, \"C\" for call\n",
        "\n",
        "# Simulation parameters\n",
        "n_simulations = 100000  # Number of simulations\n",
        "n_steps = int(252 * T)  # Number of daily time steps (252 trading days per year)\n",
        "dt = T / n_steps  # Time step\n",
        "\n",
        "# Monte Carlo simulation for asset paths\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))\n",
        "S_t = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t[:, 0] = S\n",
        "\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t[:, t] = S_t[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate option payoff at maturity\n",
        "if option_type == \"P\":\n",
        "    payoffs = np.maximum(K - S_t[:, -1], 0)\n",
        "elif option_type == \"C\":\n",
        "    payoffs = np.maximum(S_t[:, -1] - K, 0)\n",
        "else:\n",
        "    raise ValueError(\"Error: option type incorrect. Choose 'P' for a put option or 'C' for a call option.\")\n",
        "\n",
        "# Discounted expected payoff\n",
        "Opt_Price = np.exp(-r * T) * np.mean(payoffs)\n",
        "\n",
        "# Delta approximation\n",
        "S_up = S + 1e-4  # Slightly increase initial stock price\n",
        "S_down = S - 1e-4  # Slightly decrease initial stock price\n",
        "\n",
        "# Simulate paths for S_up\n",
        "S_t_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_up[:, 0] = S_up\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_up[:, t] = S_t_up[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for S_down\n",
        "S_t_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_down[:, 0] = S_down\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_down[:, t] = S_t_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for S_up and S_down\n",
        "if option_type == \"P\":\n",
        "    payoffs_up = np.maximum(K - S_t_up[:, -1], 0)\n",
        "    payoffs_down = np.maximum(K - S_t_down[:, -1], 0)\n",
        "elif option_type == \"C\":\n",
        "    payoffs_up = np.maximum(S_t_up[:, -1] - K, 0)\n",
        "    payoffs_down = np.maximum(S_t_down[:, -1] - K, 0)\n",
        "\n",
        "Opt_Price_up = np.exp(-r * T) * np.mean(payoffs_up)\n",
        "Opt_Price_down = np.exp(-r * T) * np.mean(payoffs_down)\n",
        "\n",
        "Delta = (Opt_Price_up - Opt_Price_down) / (2 * 1e-4)\n",
        "\n",
        "# Gamma approximation\n",
        "Gamma = (Opt_Price_up - 2 * Opt_Price + Opt_Price_down) / (1e-4)**2\n",
        "\n",
        "# Vega approximation\n",
        "vol_up = vol + 1e-4\n",
        "vol_down = vol - 1e-4\n",
        "\n",
        "# Simulate paths for vol_up\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))  # Re-generate noise\n",
        "S_t_vol_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_up[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_up[:, t] = S_t_vol_up[:, t-1] * np.exp((r - 0.5 * vol_up**2) * dt + vol_up * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for vol_down\n",
        "S_t_vol_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_down[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_down[:, t] = S_t_vol_down[:, t-1] * np.exp((r - 0.5 * vol_down**2) * dt + vol_down * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for vol_up and vol_down\n",
        "payoffs_vol_up = np.maximum(K - S_t_vol_up[:, -1], 0)\n",
        "payoffs_vol_down = np.maximum(K - S_t_vol_down[:, -1], 0)\n",
        "\n",
        "Opt_Price_vol_up = np.exp(-r * T) * np.mean(payoffs_vol_up)\n",
        "Opt_Price_vol_down = np.exp(-r * T) * np.mean(payoffs_vol_down)\n",
        "\n",
        "Vega = (Opt_Price_vol_up - Opt_Price_vol_down) / (2 * 1e-4)\n",
        "\n",
        "# Theta approximation\n",
        "T_down = T - 1 / 252  # Reduce maturity by one day\n",
        "\n",
        "# Simulate paths for T_down\n",
        "S_t_T_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_T_down[:, 0] = S\n",
        "for t in range(1, n_steps):\n",
        "    S_t_T_down[:, t] = S_t_T_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "payoffs_T_down = np.maximum(K - S_t_T_down[:, -1], 0)\n",
        "Opt_Price_T_down = np.exp(-r * T_down) * np.mean(payoffs_T_down)\n",
        "\n",
        "Theta = (Opt_Price_T_down - Opt_Price) / (1 / 252)\n",
        "\n",
        "# Rho approximation\n",
        "r_up = r + 1e-4\n",
        "r_down = r - 1e-4\n",
        "\n",
        "# Simulate paths for r_up and r_down\n",
        "Opt_Price_r_up = np.exp(-r_up * T) * np.mean(payoffs)\n",
        "Opt_Price_r_down = np.exp(-r_down * T) * np.mean(payoffs)\n",
        "\n",
        "Rho = (Opt_Price_r_up - Opt_Price_r_down) / (2 * 1e-4)\n",
        "\n",
        "print(f\"Delta = {Delta:.2f}\")\n",
        "print(f\"Gamma = {Gamma:.2f}\")\n",
        "print(f\"Vega = {Vega:.2f}\")\n",
        "print(f\"Theta = {Theta:.2f}\")\n",
        "print(f\"Rho = {Rho:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "66f2d3a1-2261-4076-9792-23553a260ed6",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "66f2d3a1-2261-4076-9792-23553a260ed6",
        "outputId": "93142763-b410-4e50-fcd1-ebe44bd3722d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "American Call Option Price = 4.34\n"
          ]
        }
      ],
      "source": [
        "# Use the Monte-Carlo methods with regular GBM process and daily simulations on an American Call option\n",
        "\n",
        "# Given parameters\n",
        "S0 = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "n_simulations = 100000\n",
        "n_steps = int(252 * T)\n",
        "dt = T / n_steps\n",
        "\n",
        "# Monte Carlo simulation for asset paths\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))\n",
        "S_t = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t[:, 0] = S0\n",
        "\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t[:, t] = S_t[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Initialize cash flows at maturity\n",
        "cash_flows = np.maximum(S_t[:, -1] - K, 0)\n",
        "\n",
        "\n",
        "for t in range(n_steps-1, 0, -1):\n",
        "    # Identify in-the-money paths\n",
        "    in_the_money = np.where(S_t[:, t] > K)[0] # For Call, in-the-money if K < S_t\n",
        "    if len(in_the_money) == 0:\n",
        "        continue\n",
        "\n",
        "    # Calculate the discounted cash flows for in-the-money paths\n",
        "    discounted_cash_flows = np.exp(-r * dt) * cash_flows[in_the_money]\n",
        "\n",
        "    X = S_t[in_the_money, t]\n",
        "    Y = discounted_cash_flows\n",
        "    poly_coeffs = np.polyfit(X, Y, 2)\n",
        "    continuation_values = np.polyval(poly_coeffs, X)\n",
        "\n",
        "    # Determine early exercise decision\n",
        "    immediate_exercise_values = S_t[in_the_money, t] - K\n",
        "    exercise_indices = np.where(immediate_exercise_values > continuation_values)[0]\n",
        "\n",
        "    # Update cash flows\n",
        "    cash_flows[in_the_money[exercise_indices]] = immediate_exercise_values[exercise_indices]\n",
        "\n",
        "# Discount cash flows back to present value\n",
        "option_price = np.mean(np.exp(-r * dt * np.arange(1, n_steps + 1))[:, None] * cash_flows) * np.exp(-r * t)\n",
        "\n",
        "print(f\"American Call Option Price = {option_price:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e2183983-a216-48ef-af7d-b9c44917dd34",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e2183983-a216-48ef-af7d-b9c44917dd34",
        "outputId": "6a666e8d-e861-43df-c09d-fc1fd8aae6a8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "American Put Option Price = 3.31\n"
          ]
        }
      ],
      "source": [
        "# Use the Monte-Carlo methods with regular GBM process and daily simulations on an American Put option\n",
        "\n",
        "# Given parameters\n",
        "S0 = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "n_simulations = 100000\n",
        "n_steps = int(252 * T)\n",
        "dt = T / n_steps\n",
        "\n",
        "# Monte Carlo simulation for asset paths\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))\n",
        "S_t = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t[:, 0] = S0\n",
        "\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t[:, t] = S_t[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Initialize cash flows at maturity\n",
        "cash_flows = np.maximum(K - S_t[:, -1], 0)\n",
        "\n",
        "for t in range(n_steps-1, 0, -1):\n",
        "    # Identify in-the-money paths\n",
        "    in_the_money = np.where(S_t[:, t] < K)[0]  # For Put, in-the-money if S_t < K\n",
        "    if len(in_the_money) == 0:\n",
        "        continue\n",
        "\n",
        "    # Calculate the discounted cash flows for in-the-money paths\n",
        "    discounted_cash_flows = np.exp(-r * dt) * cash_flows[in_the_money]\n",
        "\n",
        "    X = S_t[in_the_money, t]\n",
        "    Y = discounted_cash_flows\n",
        "    poly_coeffs = np.polyfit(X, Y, 2)\n",
        "    continuation_values = np.polyval(poly_coeffs, X)\n",
        "\n",
        "    # Determine early exercise decision\n",
        "    immediate_exercise_values = K - S_t[in_the_money, t]  # For Put, payoff is K - S_t\n",
        "    exercise_indices = np.where(immediate_exercise_values > continuation_values)[0]\n",
        "\n",
        "    # Update cash flows\n",
        "    cash_flows[in_the_money[exercise_indices]] = immediate_exercise_values[exercise_indices]\n",
        "\n",
        "# Discount cash flows back to present value\n",
        "option_price = np.mean(np.exp(-r * dt * np.arange(1, n_steps + 1))[:, None] * cash_flows) * np.exp(-r * t)\n",
        "\n",
        "print(f\"American Put Option Price = {option_price:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b415d2d6-da67-42f0-b841-74be12a3370e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b415d2d6-da67-42f0-b841-74be12a3370e",
        "outputId": "2845b3c9-a7d0-4c50-d8c7-82f162ce37a0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta = 0.57\n",
            "Gamma = -6859996763.73\n",
            "Vega = 19.55\n",
            "Theta = -9798.96\n",
            "Rho = -4.71\n"
          ]
        }
      ],
      "source": [
        "# Analyze the Greeks for an American call option using Monte Carlo methods under a general Geometric Brownian Motion (GBM) with daily time steps\n",
        "\n",
        "# Given parameters\n",
        "S = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "vol = 0.20\n",
        "option_type = \"C\"  # \"C\" for call, changed from \"P\"\n",
        "\n",
        "# Simulation parameters\n",
        "n_simulations = 100000  # Number of simulations\n",
        "n_steps = int(252 * T)  # Number of daily time steps (252 trading days per year)\n",
        "dt = T / n_steps  # Time step\n",
        "\n",
        "# Monte Carlo simulation for asset paths\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))\n",
        "S_t = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t[:, 0] = S\n",
        "\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t[:, t] = S_t[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Initialize the payoffs matrix for call option\n",
        "payoffs = np.maximum(S_t - K, 0)\n",
        "\n",
        "# Step backward through the tree to calculate the option price at each node\n",
        "for t in range(n_steps-1, 0, -1):\n",
        "    # Discounted expected payoff from continuation\n",
        "    discounted_payoff = np.exp(-r * dt) * payoffs[:, t+1]\n",
        "\n",
        "    # Identify paths where the option would be exercised\n",
        "    in_the_money = np.where(S_t[:, t] > K)[0]\n",
        "\n",
        "    if len(in_the_money) > 0:\n",
        "        # Use linear regression to estimate the continuation value\n",
        "        regression = np.polyfit(S_t[in_the_money, t], discounted_payoff[in_the_money], 2)\n",
        "        continuation_value = np.polyval(regression, S_t[in_the_money, t])\n",
        "\n",
        "        # Update the payoffs: max of exercise (intrinsic value) or continuation value\n",
        "        payoffs[in_the_money, t] = np.maximum(payoffs[in_the_money, t], continuation_value)\n",
        "\n",
        "    # Update the payoffs for early exercise\n",
        "    payoffs[:, t] = np.where(payoffs[:, t] > discounted_payoff, payoffs[:, t], discounted_payoff)\n",
        "\n",
        "# Option price is the average of the discounted payoff at the initial time step\n",
        "Opt_Price = np.exp(-r * dt) * np.mean(payoffs[:, 1])\n",
        "\n",
        "# Approximating the Greeks (as before but with early exercise considered)\n",
        "# Delta approximation\n",
        "S_up = S + 1e-4  # Slightly increase initial stock price\n",
        "S_down = S - 1e-4  # Slightly decrease initial stock price\n",
        "\n",
        "# Simulate paths for S_up\n",
        "S_t_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_up[:, 0] = S_up\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_up[:, t] = S_t_up[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for S_down\n",
        "S_t_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_down[:, 0] = S_down\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_down[:, t] = S_t_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for S_up and S_down\n",
        "payoffs_up = np.maximum(S_t_up[:, -1] - K, 0)\n",
        "payoffs_down = np.maximum(S_t_down[:, -1] - K, 0)\n",
        "\n",
        "Opt_Price_up = np.exp(-r * T) * np.mean(payoffs_up)\n",
        "Opt_Price_down = np.exp(-r * T) * np.mean(payoffs_down)\n",
        "\n",
        "Delta = (Opt_Price_up - Opt_Price_down) / (2 * 1e-4)\n",
        "\n",
        "# Gamma approximation\n",
        "Gamma = (Opt_Price_up - 2 * Opt_Price + Opt_Price_down) / (1e-4)**2\n",
        "\n",
        "# Vega approximation\n",
        "vol_up = vol + 1e-4\n",
        "vol_down = vol - 1e-4\n",
        "\n",
        "# Simulate paths for vol_up\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))  # Re-generate noise\n",
        "S_t_vol_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_up[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_up[:, t] = S_t_vol_up[:, t-1] * np.exp((r - 0.5 * vol_up**2) * dt + vol_up * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for vol_down\n",
        "S_t_vol_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_down[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_down[:, t] = S_t_vol_down[:, t-1] * np.exp((r - 0.5 * vol_down**2) * dt + vol_down * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for vol_up and vol_down\n",
        "payoffs_vol_up = np.maximum(S_t_vol_up[:, -1] - K, 0)\n",
        "payoffs_vol_down = np.maximum(S_t_vol_down[:, -1] - K, 0)\n",
        "\n",
        "Opt_Price_vol_up = np.exp(-r * T) * np.mean(payoffs_vol_up)\n",
        "Opt_Price_vol_down = np.exp(-r * T) * np.mean(payoffs_vol_down)\n",
        "\n",
        "Vega = (Opt_Price_vol_up - Opt_Price_vol_down) / (2 * 1e-4)\n",
        "\n",
        "# Theta approximation\n",
        "T_down = T - 1 / 252  # Reduce maturity by one day\n",
        "\n",
        "# Simulate paths for T_down\n",
        "S_t_T_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_T_down[:, 0] = S\n",
        "for t in range(1, n_steps):\n",
        "    S_t_T_down[:, t] = S_t_T_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "payoffs_T_down = np.maximum(S_t_T_down[:, -1] - K, 0)\n",
        "Opt_Price_T_down = np.exp(-r * T_down) * np.mean(payoffs_T_down)\n",
        "\n",
        "Theta = (Opt_Price_T_down - Opt_Price) / (1 / 252)\n",
        "\n",
        "# Rho approximation\n",
        "r_up = r + 1e-4\n",
        "r_down = r - 1e-4\n",
        "\n",
        "# Simulate paths for r_up and r_down\n",
        "Opt_Price_r_up = np.exp(-r_up * T) * np.mean(payoffs)\n",
        "Opt_Price_r_down = np.exp(-r_down * T) * np.mean(payoffs)\n",
        "\n",
        "Rho = (Opt_Price_r_up - Opt_Price_r_down) / (2 * 1e-4)\n",
        "\n",
        "print(f\"Delta = {Delta:.2f}\")\n",
        "print(f\"Gamma = {Gamma:.2f}\")\n",
        "print(f\"Vega = {Vega:.2f}\")\n",
        "print(f\"Theta = {Theta:.2f}\")\n",
        "print(f\"Rho = {Rho:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ca1dee61-6678-4ff9-bc73-f6c0076af067",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ca1dee61-6678-4ff9-bc73-f6c0076af067",
        "outputId": "bf2a4b08-aaeb-48e7-985e-76904aef1d81"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delta = -0.43\n",
            "Gamma = -4312212219.59\n",
            "Vega = 19.62\n",
            "Theta = 18610.61\n",
            "Rho = -3.17\n"
          ]
        }
      ],
      "source": [
        "# Analyze the Greeks for an American put option using Monte Carlo methods under a general Geometric Brownian Motion (GBM) with daily time steps\n",
        "\n",
        "# Given parameters\n",
        "S = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "K = 100\n",
        "vol = 0.20\n",
        "option_type = \"P\"  # \"P\" for put, \"C\" for call\n",
        "\n",
        "# Simulation parameters\n",
        "n_simulations = 100000  # Number of simulations\n",
        "n_steps = int(252 * T)  # Number of daily time steps (252 trading days per year)\n",
        "dt = T / n_steps  # Time step\n",
        "\n",
        "# Monte Carlo simulation for asset paths\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))\n",
        "S_t = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t[:, 0] = S\n",
        "\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t[:, t] = S_t[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Initialize the payoffs matrix\n",
        "payoffs = np.maximum(K - S_t, 0)\n",
        "\n",
        "# Step backward through the tree to calculate the option price at each node\n",
        "for t in range(n_steps-1, 0, -1):\n",
        "    # Discounted expected payoff from continuation\n",
        "    discounted_payoff = np.exp(-r * dt) * payoffs[:, t+1]\n",
        "\n",
        "    # Identify paths where the option would be exercised\n",
        "    in_the_money = np.where(payoffs[:, t] > 0)[0]\n",
        "\n",
        "    if len(in_the_money) > 0:\n",
        "        # Use linear regression to estimate the continuation value\n",
        "        regression = np.polyfit(S_t[in_the_money, t], discounted_payoff[in_the_money], 2)\n",
        "        continuation_value = np.polyval(regression, S_t[in_the_money, t])\n",
        "\n",
        "        # Update the payoffs: max of exercise (intrinsic value) or continuation value\n",
        "        payoffs[in_the_money, t] = np.maximum(payoffs[in_the_money, t], continuation_value)\n",
        "\n",
        "    # Update the payoffs for early exercise\n",
        "    payoffs[:, t] = np.where(payoffs[:, t] > discounted_payoff, payoffs[:, t], discounted_payoff)\n",
        "\n",
        "# Option price is the average of the discounted payoff at the initial time step\n",
        "Opt_Price = np.exp(-r * dt) * np.mean(payoffs[:, 1])\n",
        "\n",
        "# Approximating the Greeks (as before but with early exercise considered)\n",
        "# Delta approximation\n",
        "S_up = S + 1e-4  # Slightly increase initial stock price\n",
        "S_down = S - 1e-4  # Slightly decrease initial stock price\n",
        "\n",
        "# Simulate paths for S_up\n",
        "S_t_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_up[:, 0] = S_up\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_up[:, t] = S_t_up[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for S_down\n",
        "S_t_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_down[:, 0] = S_down\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_down[:, t] = S_t_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for S_up and S_down\n",
        "payoffs_up = np.maximum(K - S_t_up[:, -1], 0)\n",
        "payoffs_down = np.maximum(K - S_t_down[:, -1], 0)\n",
        "\n",
        "Opt_Price_up = np.exp(-r * T) * np.mean(payoffs_up)\n",
        "Opt_Price_down = np.exp(-r * T) * np.mean(payoffs_down)\n",
        "\n",
        "Delta = (Opt_Price_up - Opt_Price_down) / (2 * 1e-4)\n",
        "\n",
        "# Gamma approximation\n",
        "Gamma = (Opt_Price_up - 2 * Opt_Price + Opt_Price_down) / (1e-4)**2\n",
        "\n",
        "# Vega approximation\n",
        "vol_up = vol + 1e-4\n",
        "vol_down = vol - 1e-4\n",
        "\n",
        "# Simulate paths for vol_up\n",
        "Z = np.random.standard_normal((n_simulations, n_steps))  # Re-generate noise\n",
        "S_t_vol_up = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_up[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_up[:, t] = S_t_vol_up[:, t-1] * np.exp((r - 0.5 * vol_up**2) * dt + vol_up * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Simulate paths for vol_down\n",
        "S_t_vol_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_vol_down[:, 0] = S\n",
        "for t in range(1, n_steps + 1):\n",
        "    S_t_vol_down[:, t] = S_t_vol_down[:, t-1] * np.exp((r - 0.5 * vol_down**2) * dt + vol_down * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "# Calculate payoffs for vol_up and vol_down\n",
        "payoffs_vol_up = np.maximum(K - S_t_vol_up[:, -1], 0)\n",
        "payoffs_vol_down = np.maximum(K - S_t_vol_down[:, -1], 0)\n",
        "\n",
        "Opt_Price_vol_up = np.exp(-r * T) * np.mean(payoffs_vol_up)\n",
        "Opt_Price_vol_down = np.exp(-r * T) * np.mean(payoffs_vol_down)\n",
        "\n",
        "Vega = (Opt_Price_vol_up - Opt_Price_vol_down) / (2 * 1e-4)\n",
        "\n",
        "# Theta approximation\n",
        "T_down = T - 1 / 252  # Reduce maturity by one day\n",
        "\n",
        "# Simulate paths for T_down\n",
        "S_t_T_down = np.zeros((n_simulations, n_steps + 1))\n",
        "S_t_T_down[:, 0] = S\n",
        "for t in range(1, n_steps):\n",
        "    S_t_T_down[:, t] = S_t_T_down[:, t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z[:, t-1])\n",
        "\n",
        "payoffs_T_down = np.maximum(K - S_t_T_down[:, -1], 0)\n",
        "Opt_Price_T_down = np.exp(-r * T_down) * np.mean(payoffs_T_down)\n",
        "\n",
        "Theta = (Opt_Price_T_down - Opt_Price) / (1 / 252)\n",
        "\n",
        "# Rho approximation\n",
        "r_up = r + 1e-4\n",
        "r_down = r - 1e-4\n",
        "\n",
        "# Simulate paths for r_up and r_down\n",
        "Opt_Price_r_up = np.exp(-r_up * T) * np.mean(payoffs)\n",
        "Opt_Price_r_down = np.exp(-r_down * T) * np.mean(payoffs)\n",
        "\n",
        "Rho = (Opt_Price_r_up - Opt_Price_r_down) / (2 * 1e-4)\n",
        "\n",
        "print(f\"Delta = {Delta:.2f}\")\n",
        "print(f\"Gamma = {Gamma:.2f}\")\n",
        "print(f\"Vega = {Vega:.2f}\")\n",
        "print(f\"Theta = {Theta:.2f}\")\n",
        "print(f\"Rho = {Rho:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9d752f28-4308-4a6e-834d-625791b9691d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9d752f28-4308-4a6e-834d-625791b9691d",
        "outputId": "93d89b4c-92e7-420d-8206-c49a62c1f8f6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "European Call Option Price (with 110% moneyness):C = 1.19\n",
            "European Put Option Price (with 95% moneyness):P = 1.53\n",
            "Delta for Call option = 0.22\n",
            "Delta for Put option = -0.25\n",
            "Delta for portfolio B = -0.03\n",
            "Delta for portfolio C = 0.46\n"
          ]
        }
      ],
      "source": [
        "# Chapter 3 Q 7: Price an European Call option with 110% moneyness and an European Put with 95% moneyness using a Black-Scholes model\n",
        "# Given parameters\n",
        "S0 = 100\n",
        "r = 0.05\n",
        "sigma = 0.2\n",
        "T = 0.25\n",
        "\n",
        "# Strike prices for call and put\n",
        "K_C = 110\n",
        "K_P = 95\n",
        "\n",
        "# Calculating d1 and d2 for call option\n",
        "d1_C = (np.log(S0/K_C) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))\n",
        "d2_C = d1_C - sigma * np.sqrt(T)\n",
        "\n",
        "# Calculating d1 and d2 for put option\n",
        "d1_P = (np.log(S0/K_P) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))\n",
        "d2_P = d1_P - sigma * np.sqrt(T)\n",
        "\n",
        "# Calculating call and put prices using Black-Scholes\n",
        "C = S0 * norm.cdf(d1_C) - K_C * np.exp(-r * T) * norm.cdf(d2_C)\n",
        "P = K_P * np.exp(-r * T) * norm.cdf(-d2_P) - S0 * norm.cdf(-d1_P)\n",
        "\n",
        "# Delta for call and put options\n",
        "Delta_C = norm.cdf(d1_C)\n",
        "Delta_P = norm.cdf(d1_P) - 1\n",
        "\n",
        "# Portfolio Deltas\n",
        "Delta_portfolio_B = Delta_C + Delta_P  # Long Call + Long Put\n",
        "Delta_portfolio_C = Delta_C - Delta_P  # Long Call + Short Put\n",
        "\n",
        "C, P, Delta_portfolio_B, Delta_portfolio_C\n",
        "\n",
        "print(f\"European Call Option Price (with 110% moneyness):C = {C:.2f}\")\n",
        "print(f\"European Put Option Price (with 95% moneyness):P = {P:.2f}\")\n",
        "\n",
        "print(f\"Delta for Call option = {Delta_C:.2f}\")\n",
        "print(f\"Delta for Put option = {Delta_P:.2f}\")\n",
        "\n",
        "print(f\"Delta for portfolio B = {Delta_portfolio_B:.2f}\")\n",
        "print(f\"Delta for portfolio C = {Delta_portfolio_C:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "82767cc5-dcbd-4896-851f-3842faf15fec",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "82767cc5-dcbd-4896-851f-3842faf15fec",
        "outputId": "622f32ea-0b28-49b6-ecab-c33f6ed3f1c0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Up-and-Out Barrier Option Price using Monte Carlo: 0.69\n"
          ]
        }
      ],
      "source": [
        "#Use Monte-Carlo methods with daily time steps to price an Up-and-Out (UAO) barrier option.\n",
        "\n",
        "# Given parameters\n",
        "S0 = 120\n",
        "r = 0.06\n",
        "sigma = 0.30\n",
        "T = 0.6667\n",
        "K = S0\n",
        "B = 141\n",
        "n_simulations = 100000\n",
        "n_steps = 252\n",
        "\n",
        "# Time step size\n",
        "dt = T / n_steps\n",
        "\n",
        "# Pre-compute constants\n",
        "drift = (r - 0.5 * sigma**2) * dt\n",
        "diffusion = sigma * np.sqrt(dt)\n",
        "\n",
        "# Monte Carlo simulation\n",
        "np.random.seed(42)  # Set seed for reproducibility\n",
        "payoffs = np.zeros(n_simulations)\n",
        "\n",
        "for i in range(n_simulations):\n",
        "    S_t = S0\n",
        "    breach = False\n",
        "\n",
        "    for t in range(n_steps):\n",
        "        # Generate a random standard normal variable\n",
        "        Z = np.random.standard_normal()\n",
        "\n",
        "        # Update the asset price\n",
        "        S_t *= np.exp(drift + diffusion * Z)\n",
        "\n",
        "        # Check if the barrier is breached\n",
        "        if S_t >= B:\n",
        "            breach = True\n",
        "            break\n",
        "\n",
        "    # Payoff calculation (Call option)\n",
        "    if not breach:\n",
        "        payoffs[i] = max(S_t - K, 0)\n",
        "\n",
        "# Calculate the option price as the discounted average of the payoffs\n",
        "option_price = np.exp(-r * T) * np.mean(payoffs)\n",
        "\n",
        "print(f\"Up-and-Out Barrier Option Price using Monte Carlo: {option_price:.2f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ef73ead6-b914-44e9-add6-cdbb6b57dc85",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ef73ead6-b914-44e9-add6-cdbb6b57dc85",
        "outputId": "c018f171-0764-4cd9-9ed0-6cf6156085a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Up-and-In Barrier Option Price using Monte Carlo: 13.12\n"
          ]
        }
      ],
      "source": [
        "# Use Monte-Carlo methods with daily time steps to price an an Up-and-In barrier (UAI) option.\n",
        "\n",
        "# Given parameters\n",
        "S0 = 120\n",
        "K = 120\n",
        "B = 141\n",
        "r = 0.06\n",
        "sigma = 0.30\n",
        "T = 0.6667\n",
        "N = 100000\n",
        "steps = 252\n",
        "\n",
        "# Calculate time step size\n",
        "dt = T / steps\n",
        "\n",
        "# Simulate N paths of the stock price\n",
        "np.random.seed(42)  # For reproducibility\n",
        "payoffs = np.zeros(N)\n",
        "\n",
        "for i in range(N):\n",
        "    # Generate a path of the stock price\n",
        "    prices = np.zeros(steps)\n",
        "    prices[0] = S0\n",
        "    knocked_in = False\n",
        "\n",
        "    for t in range(1, steps):\n",
        "        # GBM model\n",
        "        z = np.random.normal()\n",
        "        prices[t] = prices[t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * z)\n",
        "\n",
        "        # Check for barrier breach\n",
        "        if prices[t] >= B:\n",
        "            knocked_in = True\n",
        "\n",
        "    # Calculate the payoff if the barrier is breached\n",
        "    if knocked_in:\n",
        "        payoffs[i] = max(0, prices[-1] - K)  # Call option payoff (max(0, S_T - K))\n",
        "\n",
        "# Discount the payoff back to the present\n",
        "price = np.exp(-r * T) * np.mean(payoffs)\n",
        "\n",
        "# Output the result\n",
        "print(f\"Up-and-In Barrier Option Price using Monte Carlo: {price:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f76d2deb-e43f-41a6-a670-b9ed2ff200c7",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f76d2deb-e43f-41a6-a670-b9ed2ff200c7",
        "outputId": "493a3a26-7a94-4413-af34-e79abdd15059"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Vanilla Option Price using Monte Carlo: 13.80\n"
          ]
        }
      ],
      "source": [
        "# Compute the price of the vanilla option with same characteristics in the scenario, but without any barrier.\n",
        "\n",
        "# Given parameters\n",
        "S0 = 120\n",
        "K = 120\n",
        "B = 141\n",
        "r = 0.06\n",
        "sigma = 0.30\n",
        "T = 0.6667\n",
        "N = 100000\n",
        "steps = 252\n",
        "\n",
        "# Calculate time step size\n",
        "dt = T / steps\n",
        "\n",
        "# Simulate N paths of the stock price\n",
        "np.random.seed(42)  # For reproducibility\n",
        "payoffs = np.zeros(N)\n",
        "\n",
        "for i in range(N):\n",
        "    # Generate a path of the stock price\n",
        "    prices = np.zeros(steps)\n",
        "    prices[0] = S0\n",
        "\n",
        "    for t in range(1, steps):\n",
        "        # GBM model\n",
        "        z = np.random.normal()\n",
        "        prices[t] = prices[t-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * z)\n",
        "\n",
        "    # Calculate the payoff of the vanilla call option\n",
        "    payoffs[i] = max(0, prices[-1] - K)  # Call option payoff (max(0, S_T - K))\n",
        "\n",
        "# Discount the payoff back to the present\n",
        "vanilla_price = np.exp(-r * T) * np.mean(payoffs)\n",
        "\n",
        "# Output the result\n",
        "print(f\"Vanilla Option Price using Monte Carlo: {vanilla_price:.2f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8f852fac-ee8e-4d85-8bee-7dd5b1de908b",
      "metadata": {
        "id": "8f852fac-ee8e-4d85-8bee-7dd5b1de908b"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.12.2"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}