py/HW2/TestCode_BasketSpread.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basket option implementation with Bachelier model CV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pyfeng as pf\n",
    "\n",
    "#import option_models as opt\n",
    "from option_models import basket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A trivial test case 1: \n",
    "# one asset have 100% weight (the others zero)\n",
    "# the case should be equivalent to the BSM or Normal model price\n",
    "\n",
    "spot = np.ones(4) * 100\n",
    "vol = np.ones(4) * 0.4\n",
    "weights = np.array([1, 0, 0, 0])\n",
    "divr = np.zeros(4)\n",
    "intr = 0\n",
    "cor_m = 0.5*np.identity(4) + 0.5\n",
    "texp = 5\n",
    "strike = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 0.5, 0.5, 0.5],\n",
       "       [0.5, 1. , 0.5, 0.5],\n",
       "       [0.5, 0.5, 1. , 0.5],\n",
       "       [0.5, 0.5, 0.5, 1. ]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cor_m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 0 0]\n",
      "26.570984651213593\n"
     ]
    }
   ],
   "source": [
    "print(weights)\n",
    "\n",
    "np.random.seed(123456)\n",
    "price_basket = basket.basket_price_mc(strike, spot, vol*spot, weights, texp, cor_m, bsm=False)\n",
    "print(price_basket)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.570984651213593 26.570845957870503\n"
     ]
    }
   ],
   "source": [
    "# Compare the price to normal model formula\n",
    "\n",
    "norm1 = pf.Norm(sigma=40)\n",
    "price_norm = norm1.price(strike, spot[0], texp, cp=1)\n",
    "print(price_basket, price_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.     0.9999 0.9999 0.9999]\n",
      " [0.9999 1.     0.9999 0.9999]\n",
      " [0.9999 0.9999 1.     0.9999]\n",
      " [0.9999 0.9999 0.9999 1.    ]]\n",
      "26.57211110181949 26.570845957870503\n"
     ]
    }
   ],
   "source": [
    "# A trivial test case 2\n",
    "# all assets almost perfectly correlated:\n",
    "# the case should be equivalent to the BSM or Normal model price\n",
    "\n",
    "spot = np.ones(4) * 100\n",
    "vol = np.ones(4) * 0.4\n",
    "weights = np.ones(4) * 0.25\n",
    "divr = np.zeros(4)\n",
    "intr = 0\n",
    "cor_m = 0.0001*np.identity(4) + 0.9999*np.ones((4,4))\n",
    "texp = 5\n",
    "strike = 120\n",
    "\n",
    "print( cor_m )\n",
    "\n",
    "np.random.seed(123456)\n",
    "price_basket = basket.basket_price_mc(strike, spot, vol*spot, weights, texp, cor_m, bsm=False)\n",
    "print(price_basket, price_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A full test set for basket option with exact price\n",
    "\n",
    "spot = np.ones(4) * 100\n",
    "vol = np.ones(4) * 0.4\n",
    "weights = np.ones(4) * 0.25\n",
    "divr = np.zeros(4)\n",
    "intr = 0\n",
    "cor_m = 0.5*np.identity(4) + 0.5\n",
    "texp = 5\n",
    "strike = 100\n",
    "price_exact = 28.0073695"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.25, 0.25, 0.25, 0.25]),\n",
       " array([[1. , 0.5, 0.5, 0.5],\n",
       "        [0.5, 1. , 0.5, 0.5],\n",
       "        [0.5, 0.5, 1. , 0.5],\n",
       "        [0.5, 0.5, 0.5, 1. ]]))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights, cor_m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.22782882893394 28.0073695\n"
     ]
    }
   ],
   "source": [
    "price_basket = basket.basket_price_mc(strike, spot, vol*spot, weights, texp, cor_m, bsm=False)\n",
    "print(price_basket, price_exact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [To Do] Basket option implementation based on BSM model\n",
    "## Write the similar test for BSM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "price_basket = basket.basket_price_mc(strike, spot, vol, weights, texp, cor_m, bsm=True)\n",
    "print(price_basket)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "# A trivial test case 1: \n",
    "# one asset have 100% weight (the others zero)\n",
    "# the case should be equivalent to the BSM or Normal model price\n",
    "\n",
    "spot = np.ones(4) * 100\n",
    "vol = np.ones(4) * 0.4\n",
    "weights = np.array([1, 0, 0, 0])\n",
    "divr = np.zeros(4)\n",
    "intr = 0\n",
    "cor_m = 0.5*np.identity(4) + 0.5\n",
    "texp = 5\n",
    "strike = 120\n",
    "\n",
    "print(weights)\n",
    "\n",
    "np.random.seed(123456)\n",
    "price_basket = basket.basket_price_mc(strike, spot, vol, weights, texp, cor_m, bsm=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 28.713486748445934\n"
     ]
    }
   ],
   "source": [
    "bsm1 = pf.Bsm(sigma=vol[0])\n",
    "price_bsm = bsm1.price(strike, spot[0], texp, cp=1)\n",
    "print(price_basket, price_bsm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spread option implementation based on normal model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A full test set for spread option\n",
    "\n",
    "spot = np.array([100, 96])\n",
    "vol = np.array([0.2, 0.1])\n",
    "weights = np.array([1, -1])\n",
    "divr = np.array([1, 1])*0.05\n",
    "intr = 0.1\n",
    "cor = 0.5\n",
    "cor_m = np.array([[1, cor], [cor, 1]])\n",
    "texp = 1\n",
    "strike = 0\n",
    "price_exact = 8.5132252"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.317680907159142 8.5132252\n"
     ]
    }
   ],
   "source": [
    "# MC price based on normal model\n",
    "# make sure that the prices are similar\n",
    "\n",
    "np.random.seed(123456)\n",
    "price_spread = basket.basket_price_mc(strike, spot, vol*spot, weights, texp, cor_m, intr=intr, divr=divr, bsm=False)\n",
    "print(price_spread, price_exact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spread option implementation based on BSM model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Once the implementation is finished the BSM model price should also work\n",
    "price_spread = basket.basket_price_mc(\n",
    "    strike, spot, vol*spot, weights, texp, cor_m, intr=intr, divr=divr, bsm=True)\n",
    "price_spread"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.513225229545505 0.0\n"
     ]
    }
   ],
   "source": [
    "# You also test Kirk's approximation\n",
    "kirk = pf.BsmSpreadKirk(vol, cor=cor, divr=divr, intr=intr)\n",
    "price_kirk = kirk.price(strike, spot, texp)\n",
    "print(price_kirk, price_spread)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [To Do] Complete the implementation of basket_price_norm_analytic\n",
    "# Compare the MC stdev of BSM basket prices from with and without CV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The basket option example from above\n",
    "spot = np.ones(4) * 100\n",
    "vol = np.ones(4) * 0.4\n",
    "weights = np.array([1, 1, 1, 1])/4\n",
    "divr = np.zeros(4)\n",
    "intr = 0\n",
    "cor_m = 0.5*np.identity(4) + 0.5\n",
    "texp = 5\n",
    "strike = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Make sure that the analytic normal price is correctly implemented\n",
    "basket.basket_price_norm_analytic(strike, spot, vol*spot, weights, texp, cor_m, intr=intr, divr=divr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run below about 100 times and get the mean and stdev\n",
    "\n",
    "### Returns 2 prices, without CV and with CV \n",
    "price_basket = basket.basket_price_mc_cv(strike, spot, vol, weights, texp, cor_m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0.]\n"
     ]
    }
   ],
   "source": [
    "print(price_basket)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}