python/examples/pricingExample.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pricing Example using Atlas (with AD)\n",
    "\n",
    "- Updated: 2023-06-29 \n",
    "- Status: Deprecated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Atlas\n",
    "import pandas as pd"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atlas uses tape-based AD (C++'s XAD library). This will be used later for sensitivities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    tape = Atlas.Tape()\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialize market variables\n",
    "\n",
    "Market variables are stored in the ```MarketStore```, we add the rate curves, rate indexes and fx exchange rates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "evalDate = Atlas.Date(1, Atlas.August, 2020)\n",
    "store = Atlas.MarketStore(evalDate, Atlas.CLP()) # store with CLP as base currency\n",
    "\n",
    "# define curve\n",
    "curveDayCounter = Atlas.Actual360()\n",
    "curveCompounding = Atlas.Simple\n",
    "curveFrequency = Atlas.Annual\n",
    "\n",
    "clpRate = Atlas.Dual(0.03)\n",
    "usdRate = Atlas.Dual(0.01)\n",
    "fx = Atlas.Dual(800)\n",
    "\n",
    "# we need to register the input to the tape for later use\n",
    "tape.registerInput(clpRate) \n",
    "tape.registerInput(usdRate) \n",
    "tape.registerInput(fx) \n",
    "tape.newRecording() # start recording, for later use\n",
    "\n",
    "\n",
    "# add CLP Curve\n",
    "strategy = Atlas.FlatForwardStrategy(evalDate, clpRate, curveDayCounter, curveCompounding, curveFrequency)\n",
    "clpCurve = Atlas.YieldTermStructure(strategy)\n",
    "index = Atlas.RateIndex(evalDate, curveFrequency, curveDayCounter, curveFrequency, curveCompounding)\n",
    "store.addCurve(\"CLP\", clpCurve, index, Atlas.CLP())\n",
    "\n",
    "# add USD Curve\n",
    "strategy = Atlas.FlatForwardStrategy(evalDate, usdRate, curveDayCounter, curveCompounding, curveFrequency)\n",
    "usdCurve = Atlas.YieldTermStructure(strategy)\n",
    "store.addCurve(\"USD\", usdCurve, index, Atlas.USD())\n",
    "\n",
    "# add FX\n",
    "store.addExchangeRate(Atlas.CLP(), Atlas.USD(), fx)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create an instrument\n",
    "\n",
    "We initialize the instrument with the corresponding discount curve id (passing the context parameter). As default, instrument coupon's are set as \"local\" currency, meaning that their current currency will match the store local currency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define interest rate\n",
    "rateValue = Atlas.Dual(0.05)\n",
    "dayCounter = Atlas.Thirty360()\n",
    "compounding = Atlas.Simple\n",
    "frequency = Atlas.Annual\n",
    "\n",
    "rate = Atlas.InterestRate(rateValue, dayCounter, compounding, frequency)\n",
    "discountContext = store.curveContext(\"CLP\")\n",
    "# define zero coupon instrument\n",
    "notional = 100\n",
    "startDate = evalDate\n",
    "endDate = Atlas.Date(1, Atlas.August, 2025)\n",
    "paymentFrequency = Atlas.Semiannual\n",
    "instrument = Atlas.FixedRateBulletInstrument(startDate, endDate, paymentFrequency, notional, rate, discountContext)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inspect the cashflows\n",
    "We can use the CashflowProfiler visitor to check the instrument cashflows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Interest</th>\n",
       "      <th>Redemptions</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-02-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-08-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-02-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2022-08-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-02-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-08-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-02-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2024-08-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2025-02-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2025-08-01</th>\n",
       "      <td>2.5</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Interest  Redemptions\n",
       "2021-02-01       2.5          NaN\n",
       "2021-08-01       2.5          NaN\n",
       "2022-02-01       2.5          NaN\n",
       "2022-08-01       2.5          NaN\n",
       "2023-02-01       2.5          NaN\n",
       "2023-08-01       2.5          NaN\n",
       "2024-02-01       2.5          NaN\n",
       "2024-08-01       2.5          NaN\n",
       "2025-02-01       2.5          NaN\n",
       "2025-08-01       2.5        100.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "profiler = Atlas.CashflowProfiler()\n",
    "profiler.visit(instrument)\n",
    "interest = profiler.interests()\n",
    "redemptions = profiler.redemptions()\n",
    "\n",
    "df = pd.DataFrame({\"Interest\": interest, \"Redemptions\": redemptions})\n",
    "df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation process"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Index the instrument\n",
    "In the indexing phase, market variables are obtained and stored in a MarketRequest object. This information will be used by a Model, which is in charge of producing all the market data needed for later calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "indexer = Atlas.Indexer()\n",
    "indexer.visit(instrument)\n",
    "request = indexer.request()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Setup a model and simulate market variables\n",
    "Currently the only model available (SpotMarketDataModel), takes the market information and generates values assuming common linear product's assumptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Atlas.SpotMarketDataModel(request, store)\n",
    "marketData = model.marketData(evalDate)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Setup a visitor and evaluate\n",
    "Visitor are the ones in charge to do evaluations. When visiting, Visitor will execute the precise code needed for each type of instrument."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Instrument NPV: ```NPVCalculator```\n",
    "\n",
    "This visitor calculates the NPV of each instruments and adds it to an internal variables called npv_, so if it visits many instrument, the value returned by ```results``` will be the sum of each NPV. In the case of a fixed bond, the NPV is being calculated as:\n",
    "\n",
    "$$NPV^l = \\frac{\\Sigma_{1}^{N}c_{i}^{f}df^{f}_{i}}{fx^{f/l}}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NPV: 109.8990\n"
     ]
    }
   ],
   "source": [
    "npv = Atlas.Dual(0.0)\n",
    "tape.registerOutput(npv)\n",
    "\n",
    "npvCalculator = Atlas.NPVCalculator(marketData)\n",
    "npvCalculator.visit(instrument)\n",
    "npv = npvCalculator.results()\n",
    "print(\"NPV: {:.4f}\".format(Atlas.getValue(npv)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to calculate the insturment duration, we can use the tape (AD). In this case, the duration is being calculated as:\n",
    "\n",
    "$$Dur = \\frac{dNPV}{dr}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CLP Rate Sens: -0.0439\n",
      "USD Rate Sens: 0.0000\n",
      "Fx Rate Sens: 0.0000\n"
     ]
    }
   ],
   "source": [
    "npv.setDerivative(1)\n",
    "tape.computeAdjoints()\n",
    "print(\"CLP Rate Sens: {:.4f}\".format(clpRate.getDerivative()*0.0001))\n",
    "print(\"USD Rate Sens: {:.4f}\".format(usdRate.getDerivative()*0.0001))\n",
    "print(\"Fx Rate Sens: {:.4f}\".format(fx.getDerivative()))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Fixed Income Par Rate: ```ParSolver```\n",
    "\n",
    "This visitor calculates the par rate of a given instrument (in this case, rates are not \"accumulated\" as before). The par rate is calculated, for a fixed rate instruments as follows:\n",
    "\n",
    "$$r = \\argmin_r (\\frac{\\Sigma_{1}^{T}c_{i}(r) df_{i}}{N} - df_0)^2$$\n",
    "\n",
    "Where $df_0$ helps bringing the disbursement to the current evaluation date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Par Rate: 2.8579%\n"
     ]
    }
   ],
   "source": [
    "parSolver = Atlas.ParSolver(marketData)\n",
    "parSolver.visit(instrument)\n",
    "rate = parSolver.results()\n",
    "print(\"Par Rate: {:.4f}%\".format(Atlas.getValue(rate)*100))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Fixed Income Z-Spread: ```ZSpreadCalculator```\n",
    "\n",
    "This visitor calculates the z-spread of a fixed rate instrument (does not apply to other types of instruments). \n",
    "\n",
    "$$s = \\argmin_s ({\\Sigma_{1}^{N}c_{i} df_{i}(s)} - NPV_{target})^2$$\n",
    "\n",
    "Where $df_i$ will be calculated using the given day counter, compounding and frequency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z-spread: CLP+249.06 bps\n"
     ]
    }
   ],
   "source": [
    "targetNPV = Atlas.Dual(100)\n",
    "zspreadCalculator = Atlas.ZSpreadCalculator(marketData, targetNPV, curveDayCounter, curveCompounding, curveFrequency)\n",
    "zspreadCalculator.visit(instrument)\n",
    "zspread = zspreadCalculator.results()\n",
    "print(\"Z-spread: CLP+{:.2f} bps\".format(Atlas.getValue(zspread)*10000))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aside: Currency change\n",
    "\n",
    "We now change the setup, we asume we are pricing a instrument in a different currency (USD) than the local one (CLP). In this case, we would expect the pricing system to convert all cashflows and sensitivites to local currency amounts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NPV: 95598.9505\n"
     ]
    }
   ],
   "source": [
    "instrument.currency(Atlas.USD())\n",
    "instrument.discountCurveContext(store.curveContext(\"USD\"))\n",
    "\n",
    "indexer.clear()\n",
    "indexer.visit(instrument)\n",
    "request = indexer.request()\n",
    "\n",
    "model = Atlas.SpotMarketDataModel(request, store) ## maybe add a setRequest method\n",
    "marketData = model.marketData(evalDate)\n",
    "\n",
    "# npv calculation\n",
    "npvCalculator = Atlas.NPVCalculator(marketData) ## maybe add a setMarketData method\n",
    "npvCalculator.visit(instrument)\n",
    "npv = npvCalculator.results()\n",
    "print(\"NPV: {:.4f}\".format(Atlas.getValue(npv)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CLP Rate Sens: 0.0000\n",
      "USD Rate Sens: -41.9628\n",
      "Fx Rate Sens: 119.4987\n"
     ]
    }
   ],
   "source": [
    "# adjoint calculation\n",
    "tape.clearDerivatives()\n",
    "npv.setDerivative(1)\n",
    "tape.computeAdjoints()\n",
    "print(\"CLP Rate Sens: {:.4f}\".format(clpRate.getDerivative()*0.0001))\n",
    "print(\"USD Rate Sens: {:.4f}\".format(usdRate.getDerivative()*0.0001))\n",
    "print(\"Fx Rate Sens: {:.4f}\".format(fx.getDerivative()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dual(103991.515317)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from Atlas.visitors import *\n",
    "instrument.applyCcy(True)\n",
    "newIndexer = IndexingVisitor()\n",
    "newIndexer(instrument)\n",
    "request  = newIndexer.getResults()\n",
    "\n",
    "model.marketRequest(request)\n",
    "marketData = model.marketData(evalDate)\n",
    "\n",
    "newNPVVisitor = NPVConstVisitor(marketData)\n",
    "newNPVVisitor.visit(instrument)\n",
    "\n",
    "newNPVVisitor.getResults()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "103991.51531674365"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "npv = 0\n",
    "\n",
    "for coupon in instrument.leg().coupons():\n",
    "    dfIdx = coupon.dfIdx()\n",
    "    fxIdx = coupon.fxIdx()\n",
    "    df = Atlas.getValue(marketData.dfs[dfIdx])\n",
    "    fx = Atlas.getValue(marketData.fxs[fxIdx])\n",
    "    npv += Atlas.getValue(coupon.amount()) * df / fx\n",
    "\n",
    "for redemption in instrument.leg().redemptions():\n",
    "    dfIdx = redemption.dfIdx()\n",
    "    fxIdx = redemption.fxIdx()\n",
    "    df = Atlas.getValue(marketData.dfs[dfIdx])\n",
    "    fx = Atlas.getValue(marketData.fxs[fxIdx])\n",
    "    npv += Atlas.getValue(redemption.amount()) * df / fx\n",
    "\n",
    "npv"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}