8_Interesr_Rate_Swap.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import datetime\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import QuantLib as ql"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from quant_lib.swap_curve import get_quote, swap_curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class IRS():\n",
    "    def __init__(self, today, pricing_date, maturity_date, irs_rate, notional, position, spread=0.0):\n",
    "        \n",
    "        # initial setup\n",
    "        self.date = today\n",
    "        self.curve = self.CURVE(self.date)\n",
    "\n",
    "        self.pricing_date = ql.Date(pricing_date.day, pricing_date.month, pricing_date.year)\n",
    "        self.maturity_date = ql.Date(maturity_date.day, maturity_date.month, maturity_date.year)\n",
    "\n",
    "        self.calendar = ql.UnitedStates()\n",
    "        self.convention = ql.ModifiedPreceding\n",
    "        self.day_counter = ql.Actual360()\n",
    "\n",
    "        self.fixed_tenor = ql.Period(1, ql.Years)\n",
    "        self.float_tenor = ql.Period(3, ql.Months)\n",
    "\n",
    "        self.irs_rate = irs_rate\n",
    "        self.notional = notional\n",
    "        if position == 'long':\n",
    "            self.position = ql.VanillaSwap.Payer\n",
    "        else:\n",
    "            self.position = ql.VanillaSwap.Receiver\n",
    "\n",
    "        self.spread = spread\n",
    "\n",
    "        # pricing result\n",
    "        self.npv = self.PRICING(self.curve)\n",
    "        self.delta = self.DELTA()\n",
    "        self.theta = self.THETA()\n",
    "    \n",
    "    def CURVE(self, date):\n",
    "        return swap_curve(date, get_quote(date))\n",
    "    \n",
    "\n",
    "    def PRICING(self, curve):\n",
    "\n",
    "        #yield term structure\n",
    "        curve_handle = ql.YieldTermStructureHandle(curve)\n",
    "\n",
    "        # USD 3M Libor\n",
    "        float_index = ql.USDLibor(ql.Period(3, ql.Months), curve_handle)\n",
    "\n",
    "        # Fixed Schedule\n",
    "        fixedSchedule= ql.Schedule(self.pricing_date, # effectiveDate\n",
    "                                    self.maturity_date, # terminationDate\n",
    "                                    self.fixed_tenor, # tenor\n",
    "                                    self.calendar, # calendar\n",
    "                                    self.convention, # convention\n",
    "                                    self.convention, # terminationDateConvention\n",
    "                                    ql.DateGeneration.Backward, # rule\n",
    "                                    False  # endOfMonth\n",
    "                    )\n",
    "\n",
    "        # Fixed Schedule\n",
    "        floatingSchedule= ql.Schedule(self.pricing_date, # effectiveDate\n",
    "                                    self.maturity_date, # terminationDate\n",
    "                                    self.float_tenor, # tenor\n",
    "                                    self.calendar, # calendar\n",
    "                                    self.convention, # convention\n",
    "                                    self.convention, # terminationDateConvention\n",
    "                                    ql.DateGeneration.Backward, # rule\n",
    "                                    False # endOfMonth\n",
    "                    )\n",
    "\n",
    "\n",
    "        # Interest Rate Swap\n",
    "        irs = ql.VanillaSwap(self.position,\n",
    "                            self.notional,\n",
    "                            fixedSchedule,\n",
    "                            self.irs_rate,\n",
    "                            self.day_counter,\n",
    "                            floatingSchedule,\n",
    "                            float_index,\n",
    "                            self.spread,\n",
    "                            self.day_counter\n",
    "                )\n",
    "\n",
    "        # pricing engine\n",
    "        swapEngine = ql.DiscountingSwapEngine(curve_handle)\n",
    "        irs.setPricingEngine(swapEngine)\n",
    "\n",
    "        # IRS pricing\n",
    "        npv = irs.NPV()\n",
    "        \n",
    "        return npv\n",
    "\n",
    "    \n",
    "    def DELTA(self):\n",
    "       # delta is change in values if 1bp of interest rate curve changes\n",
    "       # in here we use KRD (Key Rate Delta) not DV01\n",
    "       # KRD means how each tenor changes\n",
    "        curve_handle = ql.YieldTermStructureHandle(self.curve)\n",
    "\n",
    "        basis_point = 0.0001\n",
    "\n",
    "        # irs price when 1bp up\n",
    "        up_curve = ql.ZeroSpreadedTermStructure(\n",
    "                                                curve_handle,\n",
    "                                                ql.QuoteHandle(ql.SimpleQuote(basis_point))\n",
    "                                                )\n",
    "        up_irs = self.PRICING(up_curve)\n",
    "\n",
    "        down_curve = ql.ZeroSpreadedTermStructure(\n",
    "                                                curve_handle,\n",
    "                                                ql.QuoteHandle(ql.SimpleQuote(-basis_point))\n",
    "                                                )\n",
    "        down_irs = self.PRICING(down_curve)\n",
    "\n",
    "        #DV01 \n",
    "        delta = (up_irs - down_irs)/2\n",
    "        \n",
    "        return delta\n",
    "\n",
    "    def THETA(self):\n",
    "        # theta is change in value if one unit time passes.\n",
    "        # in here, unit time is 1 day\n",
    "        # since derivative product have time value, time to maturity is major variable in pricing derivatives\n",
    "        price_t0 = self.PRICING(self.CURVE(self.date))\n",
    "        price_t1 = self.PRICING(self.CURVE(self.date + datetime.timedelta(days=1)))\n",
    "\n",
    "        return price_t1 - price_t0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "todays_date = datetime.date(2020, 10, 9)\n",
    "pricing_date = datetime.date(2021, 1, 9)\n",
    "maturity_date = datetime.date(2021, 4, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "position = 'long'\n",
    "irs_rate = 0.00218\n",
    "notional = 1000000\n",
    "\n",
    "irs = IRS(\n",
    "    today=todays_date,\n",
    "    pricing_date=pricing_date,\n",
    "    maturity_date=maturity_date,\n",
    "    irs_rate=irs_rate,\n",
    "    notional=notional,\n",
    "    position=position,\n",
    "    spread=0.0\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "price of IRS = 16.134813731714075\n",
      "delta of IRS = 25.262571390637277\n",
      "theta of IRS = -2.3642255974538102\n"
     ]
    }
   ],
   "source": [
    "print(\"price of IRS = {}\".format(irs.npv))\n",
    "print(\"delta of IRS = {}\".format(irs.delta))\n",
    "print(\"theta of IRS = {}\".format(irs.theta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('ficc')",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "83e67ead297887cf4681aabdd4139a58e8981f88e12ca615f7aa3bb29e6223c9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}