Quantlib solver not yielding the same yield to maturity as BondFunctions::yield - c++

Question

I want to fully understand how Quantlib's solver works to compute the Z-spread for a floating rate bond given a forecasting term structure and a discounting term structure. To do this, first I created a simple auxiliary class to compute the yield to maturity of a bond which I will be using along with the solver (I chose Brent) to compare the yield computations against BondFunctions::yield. Nonetheless I am getting two different results for three sample bonds and I don't understand why.
First I create an auxiliary class to compute numerically the yield to maturity of a bond using quantlib's solvers
class ytmsolver{
private:
const Real obsPrice;
const Bond& bondObject;
const Date& date;
DayCounter dayCounter;
Compounding compounding;
Frequency frequency;
public:
//constructor
ytmsolver(const Bond &bond, Real &price, Date &settlementDate, DayCounter& dc, Compounding& comp,
Frequency& freq):bondObject(bond),obsPrice(price),date(settlementDate), dayCounter(dc),
compounding(comp),frequency(freq){};
//overloaded operator to be used in the solver
Real operator()(const Rate& rate)const{
return (bondObject.cleanPrice(rate,dayCounter,compounding,frequency)-obsPrice);
}
};
Then I create a floating rate bond factory that creates a floater with an index, a forecating term structure (assumed to be flat for simplicity of computations for the moment) and a pricing engine.
FloatingRateBond flatTermStructureFloaterFactory(Natural indexTenor, Frequency freq, Date tradeDate,
Date settlementDate,Natural settlementDays, Real faceAmount, const Schedule &schedule,
const Calendar& calendar,const Real &currentLiborFixing,const Real& lastResetDateLiborFixing,
const DayCounter &accrualDayCounter,
BusinessDayConvention paymentConvention=Following, Natural fixingDays=Null< Natural >(),
const std::vector< Real > &gearings=std::vector< Real >(1, 1.0),
const std::vector< Spread > &spreads=std::vector< Spread >(1, 0.0),
const std::vector< Rate > &caps=std::vector< Rate >(),
const std::vector< Rate > &floors=std::vector< Rate >(),
bool inArrears=false, Real redemption=100.0, const Date &issueDate=Date()){
//***********Term structure declaration***********
//term structure for the cash flows using a libor index
RelinkableHandle<YieldTermStructure> liborTermStructure;
//Libor index which is tied to the Frequency of payments or index tenor
boost::shared_ptr<IborIndex> libor(new USDLibor(Period(indexTenor,Months),liborTermStructure));
//term structure to forecast rest of cash flows
boost::shared_ptr<YieldTermStructure> flatforecast(
new FlatForward(settlementDate, currentLiborFixing, accrualDayCounter, Simple, freq));
liborTermStructure.linkTo(flatforecast);
//Relinkable handle to assign to the price engine.
RelinkableHandle<YieldTermStructure> discountingTermStructure;
//***********Bond object creation***********
FloatingRateBond floatingRateBondInstance(settlementDays, faceAmount,
schedule, libor, accrualDayCounter,
paymentConvention, fixingDays,
// gearings
gearings,
// spreads
spreads);
//*********Finds the last reset date****************
Date lastResetDate;
Leg cashflows=floatingRateBondInstance.cashflows();
/*
Finds the last reset date by browsing through the cashflow dates and offsetting them by
the number of fixing days and a provided calendar.
(ONLY WORKS WITH BONDS WITH THE SAME INDEX AS PERIODICITY)
If this date is provided by the flat file then this search is completely unnecessary
*/
for (Size i=0; i<cashflows.size()-1; i++) {
//Takes the lastResetDate to be the las ocurred date prior the the tradeDate
if ((cashflows[i]->hasOccurred(tradeDate, true))) {
lastResetDate=calendar.advance(cashflows[i]->date(),-fixingDays, Days,paymentConvention);
//cout<<lastResetDate<<endl; //used to print the dates as a debug method.
}
}
cout<<"lastResetDate: "<<lastResetDate<<endl; //prints it to ensure that its correct.
//*********Adds the previous libor rate associated to the last reset date*************
libor->addFixing(lastResetDate, lastResetDateLiborFixing); //last reset date minus fixing days
//***********Bond Engine declaration***********
boost::shared_ptr<PricingEngine> bondEngine(new DiscountingBondEngine (discountingTermStructure));
floatingRateBondInstance.setPricingEngine(bondEngine); //setting the pricing engine for the bond
return floatingRateBondInstance;
}
after this I create a simple function that calls Quantlib's bondfunctions and computes the yield for a bond (which I use as one way to compute the yield of the given floating rate bond.
Real priceToYieldFlatTermStructure(const Bond& bond,
Real cleanPrice,
const DayCounter& dayCounter,
Compounding compounding,
Frequency frequency,
Date settlement,
Real accuracy=1e-50,
Size maxIterations=10000){
//Calls the bond function yield which takes a bond, a clean price, a day count, a compounding,
//a frequency of payments, a settlement date, a degree of accuracy and the number of max iterations to
//reach the yield.
Real irr=BondFunctions::yield(bond,cleanPrice,dayCounter,compounding,frequency,
settlement,accuracy,maxIterations);
return irr;
}
and then I try to use Quantlib's solver to get the yield of these bonds given a clean price and I get different results using the following code:
int main(){
try {
Brent solver;
Real accuracy=1e-30, guess=0.00, min=-1.0, max=0.5;
cout<<"*******************************************"<<endl;
cout<<"Bond # 1: US4042Q0HC65"<<endl;
cout<<"*******************************************"<<endl;
//***********Input declaration***********
Natural settlementDays = 3;
Natural fixingdays=2;
Natural indexTenor=6;
Date tradeDate(02,Mar,2015);
Date issueDate(9,Aug,2006);
Date maturityDate(22,Aug,2016);
Real resetMargin=0.016;
Real indexMultiplier=1.0;
Frequency frequency=Semiannual;
Calendar holidayCalendar=UnitedStates(UnitedStates::NYSE);
BusinessDayConvention businessDayConvention= BusinessDayConvention(ModifiedFollowing);
DayCounter dayCounter=Actual360();
Real lastResetDateLiborFixing=0.003853;
Real currentLiborFixing=0.003842;
Real redemption=100;
string settlementcode="BDY"; //internal settlementcode
string settlementvalue="3"; //internal settlementvalue
Date settlementDate=getSettlementDate(tradeDate,holidayCalendar,settlementcode,settlementvalue); //function call to get the settlement date (this is working properly)
cout<<"settlementDate :"<<settlementDate<<endl;
Compounding compounding=Compounded;
Real faceAmount = redemption;
Real obsprice=101.431;
Schedule schedule(issueDate, maturityDate, Period(frequency),
holidayCalendar, businessDayConvention, businessDayConvention,
DateGeneration::Backward, true);
//***********Bond creation to be priced***********
FloatingRateBond floatingRateBondInstance1=flatTermStructureFloaterFactory(indexTenor,frequency,tradeDate,settlementDate,
settlementDays,faceAmount,schedule,holidayCalendar,currentLiborFixing,lastResetDateLiborFixing,
dayCounter,businessDayConvention,fixingdays,std::vector<Real>(1, indexMultiplier),
std::vector<Rate>(1, resetMargin));
Real ytm=priceToYieldFlatTermStructure(floatingRateBondInstance1,obsprice,dayCounter,compounding,frequency,settlementDate);
//***********Bond pricing, yield and discount marging computation***********
cout<<"Clean price: "<<floatingRateBondInstance1.cleanPrice(ytm,dayCounter,compounding,frequency,settlementDate)<<endl;
cout<<"Dirty price: "<<floatingRateBondInstance1.dirtyPrice(ytm,dayCounter,compounding,frequency,settlementDate)<<endl;
cout<<"Accrued interest: "<<floatingRateBondInstance1.accruedAmount(settlementDate)<<endl;
cout<<"Yield: "<<ytm*100<<"%"<<endl;
cout<<"Discount Margin: "<<(ytm-currentLiborFixing)*100<<"%"<<endl;
//***************solver testing***************
Real irr=solver.solve(ytmsolver(floatingRateBondInstance1,obsprice,settlementDate,dayCounter,
compounding,frequency),accuracy,guess,min,max);
cout<<"irr: "<<irr*100<<"%"<<endl;
cout<<"*******************************************"<<endl;
cout<<"Bond # 2: US4042Q0HB82"<<endl;
cout<<"*******************************************"<<endl;
//***********Input declaration***********
indexTenor=6;
issueDate=Date(27,Jul,2006);
maturityDate=Date(20,Jul,2016);
resetMargin=0.0151;
indexMultiplier=1.0;
frequency=Semiannual;
holidayCalendar=TARGET();
//holidayCalendar=UnitedStates(UnitedStates::NYSE); //not counting martin luther king day, jan 15,15 as last reset date
businessDayConvention=BusinessDayConvention(ModifiedFollowing);
dayCounter=Actual360();
lastResetDateLiborFixing=0.003549;
currentLiborFixing=0.003842;
redemption=100;
settlementcode="BDY"; //internal settlement code
settlementvalue="3"; //internal settlement value
settlementDate=getSettlementDate(tradeDate,holidayCalendar,settlementcode,settlementvalue); //function call to get the settlement date (this is working properly)
cout<<"settlementDate :"<<settlementDate<<endl;
compounding=Compounded;
faceAmount = redemption;
obsprice=100.429;
schedule=Schedule(issueDate, maturityDate, Period(frequency),
holidayCalendar, businessDayConvention, businessDayConvention,
DateGeneration::Backward, true);
//***********Bond creation to be priced***********
FloatingRateBond floatingRateBondInstance2=flatTermStructureFloaterFactory(indexTenor,frequency,tradeDate,settlementDate,
settlementDays,faceAmount,schedule,holidayCalendar,currentLiborFixing,lastResetDateLiborFixing,
dayCounter,businessDayConvention,fixingdays,std::vector<Real>(1, indexMultiplier),
std::vector<Rate>(1, resetMargin));
ytm=priceToYieldFlatTermStructure(floatingRateBondInstance2,obsprice,dayCounter,compounding,frequency,settlementDate);
//***********Bond pricing, yield and discount marging computation***********
cout<<"Clean price: "<<floatingRateBondInstance2.cleanPrice(ytm,dayCounter,compounding,frequency,settlementDate)<<endl;
cout<<"Dirty price: "<<floatingRateBondInstance2.dirtyPrice(ytm,dayCounter,compounding,frequency,settlementDate)<<endl;
cout<<"Accrued interest: "<<floatingRateBondInstance2.accruedAmount(settlementDate)<<endl;
cout<<"Yield: "<<ytm*100<<"%"<<endl;
cout<<"Discount Margin: "<<(ytm-currentLiborFixing)*100<<"%"<<endl;
//***************solver testing***************
irr=solver.solve(ytmsolver(floatingRateBondInstance2,obsprice,settlementDate,dayCounter,
compounding,frequency),accuracy,guess,min,max);
cout<<"irr: "<<irr*100<<"%"<<endl;
cout<<"*******************************************"<<endl;
cout<<"Bond # 3: US59022CCT80"<<endl;
cout<<"*******************************************"<<endl;
//***********Input declaration***********
indexTenor=3;
tradeDate=Date(10,Jun,2015);
issueDate=Date(02,May,2007);
maturityDate=Date(02,May,2017);
resetMargin=0.0055;
indexMultiplier=1.0;
frequency=Quarterly;
holidayCalendar=UnitedStates(UnitedStates::NYSE); //not counting martin luther kind day, jan 15,15 as last reset date
businessDayConvention=BusinessDayConvention(ModifiedFollowing);
dayCounter=Actual360();
lastResetDateLiborFixing=0.0027875;
currentLiborFixing=0.0028785;
redemption=100;
settlementcode="BDY"; //internal settlement code
settlementvalue="3"; //internal settlement value
settlementDate=getSettlementDate(tradeDate,holidayCalendar,settlementcode,settlementvalue); //function call to get the settlement date (this is working properly)
cout<<"settlementDate :"<<settlementDate<<endl;
compounding=Compounded;
faceAmount = redemption;
obsprice=99.794;
schedule=Schedule(issueDate, maturityDate, Period(frequency),
holidayCalendar, businessDayConvention, businessDayConvention,
DateGeneration::Backward, true);
//***********Bond pricing, yield and discount marging computation***********
FloatingRateBond floatingRateBondInstance3=flatTermStructureFloaterFactory(indexTenor,frequency,tradeDate,settlementDate,
settlementDays,faceAmount,schedule,holidayCalendar,currentLiborFixing,lastResetDateLiborFixing,
dayCounter,businessDayConvention,fixingdays,std::vector<Real>(1, indexMultiplier),
std::vector<Rate>(1, resetMargin));
ytm=priceToYieldFlatTermStructure(floatingRateBondInstance3,obsprice,dayCounter,compounding,frequency,settlementDate);
//***********Bond pricing, yield and discount marging computation***********
cout<<"Clean price: "<<floatingRateBondInstance3.cleanPrice(ytm,dayCounter,compounding,frequency,settlementDate)<<endl;
cout<<"Dirty price: "<<floatingRateBondInstance3.dirtyPrice(ytm,dayCounter,compounding,frequency,settlementDate)<<endl;
cout<<"Accrued interest: "<<floatingRateBondInstance3.accruedAmount(settlementDate)<<endl;
cout<<"Yield: "<<ytm*100<<"%"<<endl;
cout<<"Discount Margin: "<<(ytm-currentLiborFixing)*100<<"%"<<endl;
//***************solver testing***************
irr=solver.solve(ytmsolver(floatingRateBondInstance3,obsprice,settlementDate,dayCounter,
compounding,frequency),accuracy,guess,min,max);
cout<<"irr: "<<irr*100<<"%"<<endl;
return 0;
} catch (exception& e) {
cerr << e.what() << endl;
return 1;
} catch (...) {
cerr << "unknown error" << endl;
return 1;
}
}
and finally I am getting the following results:
Bond # 1: US4042Q0HC65
settlementDate :March 5th, 2015
lastResetDate: February 19th, 2015
Clean price: 101.431
Dirty price: 101.486
Accrued interest: 0.0551472
Yield: 1.01286%
Discount Margin: 0.628665%
irr: 0.72216%
Bond # 2: US4042Q0HB82
settlementDate :March 5th, 2015
lastResetDate: January 16th, 2015
Clean price: 100.429
Dirty price: 100.657
Accrued interest: 0.227932
Yield: 1.57325%
Discount Margin: 1.18905%
irr: 1.47977%
Bond # 3: US59022CCT80
settlementDate :June 15th, 2015
lastResetDate: April 30th, 2015
Clean price: 99.794
Dirty price: 99.8907
Accrued interest: 0.0966875
Yield: 0.945517%
Discount Margin: 0.657667%
irr: 0.949541%
What is it that I am doing wrong here? I don't understand why the solver is not returning the same number as the bondfunction for yield. Any ideas as of why or what am I doing wrong here?

Answer 1

I'm going to assume that the yield returned the QuantLib BondFunctions::yield function is correct, since when you pass it to the cleanPrice method of the bond you get back the observed price that you used as input.
This leaves us to guess what's wrong in your function. By looking at your ytmsolver class, I notice that you're not passing the settlement date to the cleanPrice method of the bond object, as you do in the main when repricing the code.
When the settlement date is missing, the method assumes that it's today's settlement date—that is, three business days from today. This is significantly later than the settlement dates that you wanted and that you output in the main function, and so you get the wrong yield. Once you pass the settlement date to cleanPrice, the solver returns the expected value.