Pricing floating legs of interest rate swaps

In this post we will close the trilogy on (old style) swap pricing. In particular, we will look at how downloading the data for the variable rate needed to calculate the variable leg accrual.

• Part 1 gave the general idea behind tidy pricing interest rate swaps using a 7 lines pipe

• Part 2 went much more into detail and priced some real world contract comparing the results obtained vs Bloomberg and showing significantly good results.

The only part missing was calculating the accrual for the floating leg. To do this we need the information about the historical level of the interest rate to which the leg is linked.

For standard EUR contracts, this rate is the 6 months’ EURIBOR. For those of you who are interested in understanding more what this rate is can go this link

Sourcing the data is not a problem, but doing it the R way (ie. for free), can be.

Luckily the awesome Quandl data provider actually provides the information we need. Quandl is a premier source for financial, economic, and alternative datasets, serving investment professionals. Quandl’s platform is used by over 400,000 people, including analysts from the world’s top hedge funds, asset managers and investment banks.

Pulling data from Quandl is very easy using the Quandl package available on CRAN Its logic is quite simple:

Quandl::Quandl(code, start_date, end_date)

where code is a unique identifier that can be sourced from the Quandl website.

In particular, we shoudl be grateful to the Bank of France which provides all the interest rate information we need. Going on their page we can in fact find that the code for the 6 months EURIBOR rate is “BOF/QS_D_IEUTIO6M”.

Let’s then see what the output of this very simple function is with our code:

rates <- Quandl::Quandl("BOF/QS_D_IEUTIO6M", 
               start_date = lubridate::dmy("01-01-2018"), 
               end_date = lubridate::dmy("31-12-2018"))

rates %>% 
  knitr::kable(caption = "Output from Quandl", "html") %>% 
  kableExtra::kable_styling(bootstrap_options = c("striped", "hover", "condensed", "responsive")) %>% 
   kableExtra::scroll_box(height = "500px")

We now have to incorporate this code into the overall coding strategy described in the previous post

Before we dive in how I coded this, let’s see how I changed the data structure of how a swap is defined:

swap.25y <- list(notional = 10000000,
                  start.date = lubridate::ymd(20070119),
                  maturity.date = lubridate::ymd(20320119), 
                  strike = 0.00059820,
                  type = "receiver", 
                  time.unit = list(pay = 6, receive = 12), 
                  dcc = list(pay = 0, receive = 6), 
                  calendar = "TARGET")

This new data structure now allows to define - as it should be - different characteristics (like coupon frequency or day count convention) for the different legs (payer and receiver) of the swap. In particular, we can specify in the type variable whether the swap is a receiver or a payer one.

Let’s look atthe code now. The function that gets modified the most is the SwapCashflowYFCalculation which I have re-named as CashFlowPricing one which now looks as follows:

CashFlowPricing  <- function(today, start.date, maturity.date, type,
                                     time.unit, dcc, calendar) {
  # Part 1: Calculate the whole cashflow dates
  cashflows <- seq(from = 0,
                   to = (lubridate::year(maturity.date) -
                           lubridate::year(start.date)) * 12,
                   by = time.unit) %>%
    purrr::map_dbl(~RQuantLib::advance(calendar = calendar,
                                       dates = start.date,
                                       n = .x,
                                       timeUnit = 2,
                                       bdc = 1,
                                       emr = TRUE)) %>%
    lubridate::as_date() %>%
    {if (start.date < today) append(today, .) else .}

  # Part 2: calculate accrual and rate fixing days
  accrual.date <- cashflows[today - cashflows > 0]

  if (!identical(as.double(accrual.date), double(0))) {
    accrual.date  %<>%  max()
    if (stringr::str_detect(type, "floating")) {
      fixing.date <- accrual.date %>%
        {RQuantLib::advance(calendar = calendar,
                            dates = .,
                            n = -2,
                            timeUnit = 0,
                            bdc = 1,
                            emr = TRUE)}
    } else {
      fixing.date <- NULL
    }
    accrual.yf <- accrual.date %>%
      {RQuantLib::yearFraction(today, ., dcc)} %>%
      `*`(-1)
  } else {
    fixing.date <- NULL
    accrual.yf <- 0
  }

  # Part 3: Tidy and return the list of relevant dates
  cashflows %<>%
    purrr::map_dbl(~RQuantLib::yearFraction(today, .x, dcc)) %>%
    tibble::tibble(yf = .) %>%
    dplyr::filter(yf >= 0)

  return(list(cashflows = cashflows, accrual.yf = accrual.yf,
              fixing.date = fixing.date))
}

Let’s analyise the code:

• Part 1 is actually the core of the code previously described

• Part 2 is the new code. accrual.date is the date from which the accrual starts to be calculated. This gets converted into a year fraction and saved into accrual.yf. The if statement calculates the date at which the floating EURIBOR rate has to be snapped from Quandl only for the floating rate. This date is stored in the fixing.date variable and it considers a 2 days lag which is standard for the European market.

• Part 3 finally converts and returns all the future cashflows in terms of year fraction

You can note that we now calculate the cashflows for the floating leg even if it will note be used by the OLDParSwapRate function. This will be needed for future developments when we will introduce the OIS discounting…(stay tuned!!)

I can now calculate the accrual and for this purpose I developed a brand new function called CalculateAccrual

CalculateAccrual <- function(swap.dates, leg.type, swap, direction) {
  # Part 1: calculate the accrual rate
  if (!is.null(swap.dates$fixing.date)) {
    rate <- Quandl::Quandl("BOF/QS_D_IEUTIO6M",
                           start_date = swap.dates$fixing.date,
                           end_date = swap.dates$fixing.date) %>%
      tibble::as_tibble(.) %>%
      dplyr::select(Value) %>%
      as.double %>%
      `/`(100)
  } else {
    rate <- swap$strike
  }
  # Part 2: Calculate the value of the accrual
  swap.dates %>%
    purrr::pluck("accrual.yf") %>%
    `*`(swap$notional * rate * switch(leg.type, "pay" = -1, "receive" = 1))
}

This is smaller and easier function:

• Part 1: for floating legs we use Quandl to download the needed data and extract the rate information. For the fixed one, we just use the strike of the swap.

• Part 2: we calculate the actual accrual amount using the classical function

Let’s see the final result on the 25 years’ swap we use as test:

## # A tibble: 1 x 8
##   swap.id currency clean.mv dirty.mv accrual.pay accrual.receive     par
##   <chr>   <chr>       <dbl>    <dbl>       <dbl>           <dbl>   <dbl>
## 1 Swap 2… EUR      -881815. -874994.       5441.           1379. 0.00771
## # … with 1 more variable: pv01 <dbl>

Let’s compare the result with the Bloomberg screenshot

You can see that we now perfectly price also the receiving accrual and, of course, also the total one.