bonds.cpp File Reference

#include "toplevelfixture.hpp"
#include <boost/test/unit_test.hpp>
#include <ql/cashflows/fixedratecoupon.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/credit/flathazardrate.hpp>
#include <ql/termstructures/yield/flatforward.hpp>
#include <ql/time/calendars/weekendsonly.hpp>
#include <ql/time/schedule.hpp>
#include <qle/instruments/impliedbondspread.hpp>
#include <qle/pricingengines/discountingriskybondengine.hpp>
#include <boost/make_shared.hpp>

Go to the source code of this file.

Functions
	BOOST_AUTO_TEST_CASE (testBondSpreads)

Function Documentation

BOOST_AUTO_TEST_CASE()

BOOST_AUTO_TEST_CASE

(

testBondSpreads

)

Definition at line 39 of file bonds.cpp.

                                      {
 
    BOOST_TEST_MESSAGE("Testing QuantExt bond spread helper");
 
    SavedSettings backup;
    Settings::instance().evaluationDate() = Date(8, Dec, 2016);
    Date today = Settings::instance().evaluationDate();
 
    // market data
    Handle<Quote> rateQuote(QuantLib::ext::make_shared<SimpleQuote>(0.02));
    Handle<Quote> issuerSpreadQuote(QuantLib::ext::make_shared<SimpleQuote>(0.01));
    DayCounter dc = Actual365Fixed();
    Handle<YieldTermStructure> yts(QuantLib::ext::make_shared<FlatForward>(today, rateQuote, dc, Compounded, Semiannual));
    Handle<DefaultProbabilityTermStructure> dpts(QuantLib::ext::make_shared<FlatHazardRate>(today, issuerSpreadQuote, dc));
    Handle<Quote> bondSpecificSpread(QuantLib::ext::make_shared<SimpleQuote>(0.005));
 
    // build the bond
    Date startDate = today;
    Date endDate = startDate + Period(10, Years);
    Period tenor = 6 * Months;
    Calendar calendar = WeekendsOnly();
    BusinessDayConvention bdc = Following;
    BusinessDayConvention bdcEnd = bdc;
    DateGeneration::Rule rule = DateGeneration::Forward;
    bool endOfMonth = false;
    Date firstDate, lastDate;
    Schedule schedule(startDate, endDate, tenor, calendar, bdc, bdcEnd, rule, endOfMonth, firstDate, lastDate);
 
    Real redemption = 100.0;
    Real couponRate = 0.04;
    Leg leg =
        FixedRateLeg(schedule).withNotionals(redemption).withCouponRates(couponRate, dc).withPaymentAdjustment(bdc);
 
    QuantLib::ext::shared_ptr<QuantLib::Bond> bond(QuantLib::ext::make_shared<QuantLib::Bond>(0, WeekendsOnly(), today, leg));
    Handle<Quote> recovery;
    QuantLib::ext::shared_ptr<PricingEngine> pricingEngine(
        QuantLib::ext::make_shared<QuantExt::DiscountingRiskyBondEngine>(yts, dpts, recovery, bondSpecificSpread, 1 * Months));
    bond->setPricingEngine(pricingEngine);
 
    Real price = bond->dirtyPrice();
    BOOST_TEST_MESSAGE("Bond price = " << price);
 
    // now calculated the implied bond spread, given the price
    QuantLib::ext::shared_ptr<SimpleQuote> tmpSpread = QuantLib::ext::make_shared<SimpleQuote>(0.0);
    Handle<Quote> tmpSpreadH(tmpSpread);
    QuantLib::ext::shared_ptr<PricingEngine> tmpEngine;
    tmpEngine.reset(new QuantExt::DiscountingRiskyBondEngine(yts, dpts, recovery, tmpSpreadH, 1 * Months));
 
    Real impliedSpread = QuantExt::detail::ImpliedBondSpreadHelper::calculate(bond, tmpEngine, tmpSpread, price, false,
                                                                              1.e-12, 10000, -0.02, 1.00);
    BOOST_TEST_MESSAGE("Implied spread = " << impliedSpread);
    BOOST_CHECK_CLOSE(impliedSpread, bondSpecificSpread->value(), 0.0001);
 
    Real price2 = bond->dirtyPrice();
    BOOST_CHECK_EQUAL(price, price2);
 
    // which spread would mean the bond price is par?
    Real parRedemption = 100.0;
    Real impliedSpreadPar = QuantExt::detail::ImpliedBondSpreadHelper::calculate(
        bond, tmpEngine, tmpSpread, parRedemption, false, 1.e-12, 10000, -0.02, 1.00);
    BOOST_TEST_MESSAGE("Par bond price would require spread of " << impliedSpreadPar);
    BOOST_CHECK_EQUAL(
        price, bond->dirtyPrice()); // ensure hypothetical impliedSpread calc has not affected the original position
 
    QuantLib::ext::dynamic_pointer_cast<SimpleQuote>(*bondSpecificSpread)->setValue(impliedSpreadPar);
    Real pricePar = bond->dirtyPrice();
    BOOST_TEST_MESSAGE("Bond spread of " << bondSpecificSpread->value() << " means price of " << pricePar);
    BOOST_CHECK_CLOSE(pricePar, parRedemption, 0.0001);
 
    // now check that bond pricing works even if no credit curve exists
 
    dpts = Handle<DefaultProbabilityTermStructure>();
    pricingEngine.reset(new QuantExt::DiscountingRiskyBondEngine(yts, dpts, recovery, bondSpecificSpread, 1 * Months));
    tmpEngine.reset(new QuantExt::DiscountingRiskyBondEngine(yts, dpts, recovery, tmpSpreadH, 1 * Months));
    bond->setPricingEngine(pricingEngine);
    Real priceNoIssuerCurve = bond->dirtyPrice();
    BOOST_TEST_MESSAGE("Bond price (ignoring issuer spread) = " << priceNoIssuerCurve);
    impliedSpread = QuantExt::detail::ImpliedBondSpreadHelper::calculate(bond, tmpEngine, tmpSpread, priceNoIssuerCurve,
                                                                         false, 1.e-12, 10000, -0.02, 1.00);
    BOOST_TEST_MESSAGE("Bond spread (ignoring issuer spread) = " << impliedSpread);
    BOOST_CHECK_CLOSE(impliedSpread, bondSpecificSpread->value(), 0.0001);
 
    // which spread would mean the bond price is par?
    impliedSpreadPar = QuantExt::detail::ImpliedBondSpreadHelper::calculate(bond, tmpEngine, tmpSpread, parRedemption,
                                                                            false, 1.e-12, 10000, -0.02, 1.00);
    BOOST_TEST_MESSAGE("Par bond price would require spread of " << impliedSpreadPar);
    BOOST_CHECK_CLOSE(impliedSpreadPar, bondSpecificSpread->value() + issuerSpreadQuote->value(), 0.0001);
    QuantLib::ext::dynamic_pointer_cast<SimpleQuote>(*bondSpecificSpread)->setValue(impliedSpreadPar);
    pricePar = bond->dirtyPrice();
    BOOST_TEST_MESSAGE("Bond spread of " << bondSpecificSpread->value() << " means price of " << pricePar);
    BOOST_CHECK_CLOSE(pricePar, parRedemption, 0.0001);
}

Here is the call graph for this function: