Changed HW2 to use PyFENG functions

Author: jaehyukchoi

py/HW2/TestCode_BasketSpread.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Basket option implementation based on normal model"
+    "# Basket option implementation with Bachelier model CV"
    ]
   },
   {
@@ -24,19 +24,12 @@
    "outputs": [],
    "source": [
     "import numpy as np\n",
+    "import pyfeng as pf\n",
+    "\n",
     "#import option_models as opt\n",
-    "from option_models import basket\n",
-    "from option_models import bsm\n",
-    "from option_models import normal"
+    "from option_models import basket"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -49,7 +42,7 @@
     "\n",
     "spot = np.ones(4) * 100\n",
     "vol = np.ones(4) * 0.4\n",
-    "weights = np.array([0, 1, 0, 0])\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",
@@ -89,8 +82,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[0 1 0 0]\n",
-      "26.92956987643586\n"
+      "[1 0 0 0]\n",
+      "26.570984651213593\n"
      ]
     }
    ],
@@ -111,15 +104,15 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "26.92956987643586 26.570845957870503\n"
+      "26.570984651213593 26.570845957870503\n"
      ]
     }
    ],
    "source": [
     "# Compare the price to normal model formula\n",
     "\n",
-    "norm1 = normal.NormalModel(vol=40)\n",
-    "price_norm = norm1.price(strike=120, spot=100, texp=texp, cp=1)\n",
+    "norm1 = pf.Norm(sigma=40)\n",
+    "price_norm = norm1.price(strike, spot[0], texp, cp=1)\n",
     "print(price_basket, price_norm)"
    ]
   },
@@ -136,7 +129,7 @@
       " [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.761395615904505 26.570845957870503\n"
+      "26.57211110181949 26.570845957870503\n"
      ]
     }
    ],
@@ -188,10 +181,11 @@
     {
      "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. ]])"
+       "(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,
@@ -200,7 +194,7 @@
     }
    ],
    "source": [
-    "cor_m"
+    "weights, cor_m"
    ]
   },
   {
@@ -212,7 +206,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "28.168716545630815 28.0073695\n"
+      "28.22782882893394 28.0073695\n"
      ]
     }
    ],
@@ -280,6 +274,25 @@
     "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": {},
@@ -289,7 +302,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -300,22 +313,23 @@
     "weights = np.array([1, -1])\n",
     "divr = np.array([1, 1])*0.05\n",
     "intr = 0.1\n",
-    "cor_m = np.array([[1, 0.5], [0.5, 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": 14,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "8.348852807225292 8.5132252\n"
+      "8.317680907159142 8.5132252\n"
      ]
     }
    ],
@@ -337,31 +351,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "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)"
+    "    strike, spot, vol*spot, weights, texp, cor_m, intr=intr, divr=divr, bsm=True)\n",
+    "price_spread"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "8.5132252295455 0.0\n"
+      "8.513225229545505 0.0\n"
      ]
     }
    ],
    "source": [
     "# You also test Kirk's approximation\n",
-    "price_kirk = basket.spread_price_kirk(strike, spot, vol, texp, 0.5, intr, divr)\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)"
    ]
   },
@@ -375,7 +402,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -392,7 +419,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -401,7 +428,7 @@
        "0.0"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -413,7 +440,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -425,7 +452,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -439,19 +466,12 @@
    "source": [
     "print(price_basket)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "anaconda-cloud": {},
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -465,7 +485,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.5"
+   "version": "3.8.11"
   }
  },
  "nbformat": 4,

py/HW2/option_models/basket.py

@@ -6,8 +6,7 @@
 """
 import numpy as np
 import scipy.stats as ss
-from .bsm import bsm_formula
-from .normal import normal_formula
+import pyfeng as pf
 
 def basket_check_args(spot, vol, corr_m, weights):
     '''
@@ -63,7 +62,7 @@ def basket_price_mc(
     forward = spot / disc_fac * div_fac
 
     cov_m = vol * cor_m * vol[:,None]
-    chol_m = np.linalg.cholesky(cov_m)
+    chol_m = np.linalg.cholesky(cov_m)  # L matrix in slides
 
     n_assets = spot.size
     znorm_m = np.random.normal(size=(n_assets, n_samples))
@@ -94,20 +93,13 @@ def basket_price_norm_analytic(
     1. compute the forward of the basket
     2. compute the normal volatility of basket
     3. plug in the forward and volatility to the normal price formula
-    normal_formula(strike, spot, vol, texp, intr=0.0, divr=0.0, cp=1)
-    it is already imorted
+    
+    norm = pf.Norm(sigma, intr=intr, divr=divr)
+    norm.price(strike, spot, texp, cp=cp)
     
     PUT YOUR CODE BELOW
     '''
 
+    
+    
     return 0.0
-
-def spread_price_kirk(strike, spot, vol, texp, corr, intr=0, divr=0, cp=1):
-    div_fac = np.exp(-texp*divr)
-    disc_fac = np.exp(-texp*intr)
-    forward = spot / disc_fac * div_fac
-    vol2 = vol[1]*forward[1]/(forward[1]+strike)
-    vol_r = np.sqrt(vol[0]**2 + vol2*(vol2 - 2*corr*vol[0]))
-    price = disc_fac * bsm_formula(forward[1]+strike, forward[0], vol_r, texp, cp=cp)
-
-    return price