2

I am trying to price a floating rate bond and I already have the discount curve built with quantlib on C++. Now what I would like to do is to use the FloatingRateBond class and create a set of cash flows where the first cash flow is known (given that the index associated to this cash flow was known at the last reset date) and forecasting the remaining cash flows using the current index.

To make it more graphical assume annual payments and that the index at the last reset date was 1% and that the reset margin is 1%. Then the first cash flow will be 2% roughly speaking. Now assume that today's index is 2%, then I want all the remaining cash flows to be 3% (with the proper adjustments from the Day Count convention and Business Day convention).

How can I create such a cash flow structure for an instance of the FloatingRateBond class?

ZunTzu
  • 7,244
  • 3
  • 31
  • 39
Lucas Triana
  • 39
  • 5
  • Do you have any sample code? Also I don't think "floating" "rate" and "bond" are useful keywords to indicate the programming language or technology being used. – Kmeixner Jun 16 '15 at 14:41
  • Sorry for not having any sample code, I am on the structuring stage so I haven't really being able to try given that I am not sure if this is at all possible. The development is being done in C++, perhaps this clears some of your doubts too. Please let me know if you have an idea of how to tackle this using the FloatingRateBond class of Quantlib. – Lucas Triana Jun 16 '15 at 17:17
  • @LucasTriana Such a detailed explanation really needs to be marked as the answer. https://meta.stackexchange.com/questions/5234/how-does-accepting-an-answer-work – Francois Botha Sep 12 '17 at 13:58

1 Answers1

4

First I'll go quickly through building the bond, copying some code from the bonds example in the QuantLib release (also, disclaimer: I haven't tried compiling the code below). For more details on the classes involved, see the QuantLib documentation.

Let's assume annual payments as you said:

Schedule schedule(startDate, maturityDate, Period(Annual),
                  calendar, convention, convention,
                  DateGeneration::Backward, true);

and for illustration, let's assume we'll use an USD Libor index. Its future fixing are forecast based on an interest-rate term structure we'll set later.

RelinkableHandle<YieldTermStructure> liborTermStructure;
boost::shared_ptr<IborIndex> libor(
             new USDLibor(Period(1,Years),liborTermStructure));

Now build the bond, adding the margin as a spread on the LIBOR rate:

FloatingRateBond bond(settlementDays, faceAmount,
                      schedule, libor, dayCounter,
                      convention, fixingDays,
                      // gearings
                      std::vector<Real>(1, 1.0),
                      // spreads
                      std::vector<Rate>(1, 0.001));

Now to get the coupons you want, you'll just set the corresponding market data. To set the rate of the first cash flow, store the past fixing of the Libor index:

libor->addFixing(resetDate, 0.01);

And to set the future cash flows, create a flat interest-rate curve with the desired rate (minding the conventions so that they match those of the Libor index):

boost::shared_ptr<YieldTermStructure> flatRate(
    new FlatForward(today, 0.01, dayCounter, Simple, Annual));
liborTermStructure.linkTo(flatRate);

(You're not necessarily limited to a flat rate; if you can bootstrap a Libor curve, you can use that one to get realistic estimates for future coupons.)

At this point, you should be able to extract the bond coupons and check that they're as expected:

std::vector<boost::shared_ptr<CashFlow> > cashflows = bond.cashflows();
for (std::size_t i=0; i < cashflows.size(); ++i)
    std::cout << cashflows[i]->date() << "    "
              << cashflows[i]->amount() << "\n";

If you also want to call methods such as bond.cleanPrice(), you'll need to tell the bond how to discount the cash flows:

RelinkableHandle<YieldTermStructure> discountingTermStructure;
boost::shared_ptr<PricingEngine> bondEngine(
             new DiscountingBondEngine(discountingTermStructure));
bond.setPricingEngine(bondEngine);

You can use for discounting the same curve you're using for forecasting...

discountingTermStructure.linkTo(flatRate);

...or create and use a different one.

Luigi Ballabio
  • 4,128
  • 21
  • 29
  • Oh, and when the current index rate changes, there's no need to rebuild everything. Just change the flat rate, relink the handles to the new one, and the coupon amounts will update. – Luigi Ballabio Jun 17 '15 at 08:47
  • Hi Luigi, thank you very much for the prompt reply. Your approach seems to be working for different frequencies (Annual, Semiannual, Quarterly and Monthly). One thing that I noticed and is puzzling me is that for the LIBOR index, it doesn't matter what period you set it to it works for all frequencies without the need to specify the LIBOR index periodicity according. Could you help me understand why is this? – Lucas Triana Jun 17 '15 at 15:38
  • It could be because you're using a flat rate. It will get you basically the same annualized fixing for all frequencies. – Luigi Ballabio Jun 20 '15 at 18:55