Skip to content
All library documents

Compounding and Day Counts in Floating-Rate Bond Coupons

Article Quant Q&A · Author: Jessica
Read the original

Summary

This document raises a fixed-income cash-flow reconciliation question using a quarterly USD LIBOR floating-rate bond. The example sets a continuously compounded flat zero curve at five percent, uses Actual/360 for coupon accrual, and compares the expected simple-interest coupon with QuantLib’s larger calculated payment. It highlights that a continuously compounded zero rate is not itself the simple annualized rate applied directly to a coupon accrual fraction.

The supplied material contains the setup and observed cash flow, but no answer explaining the calculation. It therefore does not establish the precise source of the difference, which may depend on how the index fixing is forecast, the accrual and fixing dates, and QuantLib’s coupon conventions. The figures are a single configuration, not a general rule. Readers should distinguish the curve’s compounding convention from the index rate and coupon day-count calculation when investigating such discrepancies.

Key ideas

  • A floating-rate coupon depends on the index fixing and the coupon accrual period.
  • A continuously compounded curve quote cannot automatically be treated as a simple coupon rate.
  • Actual/360 determines the accrual fraction used to calculate interest.
  • Fixing dates and library conventions can affect the forecast coupon amount.
  • The document poses a reconciliation question but does not provide a verified explanation.

Tags

Fixed incomeStatistics
Full text
# Quantlib Floating Rate Cashflow


# Quantlib Floating Rate Cashflow












I am struggling to reconcile the cashflow of a floating rate bond. I created a reference index of 5% flat, then a bond that pays quarterly coupon with Actual/360. For example, I'd expect the coupon on 4/15/2023 (accrual from 1/15-4/15) to be 90/360*5%*100 = 1.25 exactly. Maybe it needs to be converted from continuous to simple. (exp(0.05/4)-1)*100 gives me 1.257845. Quantlib returns 1.2579326904575874. Where did this come from?

```
    flatZero5 = ql.ZeroCurve(spotDates, 
                             pd_zero_curve['Value']*0 +0.05,
                             ql.Actual360(),
                             ql.UnitedStates(), 
                             ql.Linear(), 
                             ql.Continuous, 
                             ql.NoFrequency)
    flat5handle = ql.YieldTermStructureHandle( flatZero5 )
    index1 = ql.USDLibor(ql.Period(3, ql.Months), 
                         ql.RelinkableYieldTermStructureHandle(flatZero5)
                         )    
    index1.addFixings( [ql.Date(13,1,2022),ql.Date(13,4,2022),ql.Date(13,7,2022)],   [0.05,0.05,0.05] )

    schedule = ql.MakeSchedule(ql.Date(15,1,2022), ql.Date(15,1,2042) , ql.Period('3M'))   
    bond1 = ql.FloatingRateBond(settlementDays=3,
                                faceAmount = 100,
                                schedule = schedule ,
                                index = index1,
                                paymentDayCounter = ql.Actual360(),
                                spreads = [0]
                                )
    bond_cf= bond1.cashflows() 
    print ( bond_cf[4].date()  ) # April 15th, 2023
    print (  bond_cf[4].amount()  ) # result 1.2579326904575874
    print( flat5handle.forwardRate( ql.Date(15,1,2023),
                                    ql.Date(15,4,2023),  
                                    ql.Actual360(),
                                    ql.Continuous,   
                                    ql.NoFrequency) ) # returns 5.000000 % Actual/360 continuous compounding
```

Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)

This summary was written by Stratmill's research agent from the original; it is not a copy of the source.