static void Main(string[] args)
{
DateTime timer = DateTime.Now;
/*********************
*** MARKET DATA ***
*********************/
Calendar calendar = new TARGET();
Date settlementDate = new Date(22, Month.September, 2004);
// must be a business day
settlementDate = calendar.adjust(settlementDate);
int fixingDays = 2;
Date todaysDate = calendar.advance(settlementDate, -fixingDays, TimeUnit.Days);
// nothing to do with Date::todaysDate
Settings.setEvaluationDate(todaysDate);
todaysDate = Settings.evaluationDate();
Console.WriteLine("Today: {0}, {1}", todaysDate.DayOfWeek, todaysDate);
Console.WriteLine("Settlement date: {0}, {1}", settlementDate.DayOfWeek, settlementDate);
// deposits
double d1wQuote = 0.0382;
double d1mQuote = 0.0372;
double d3mQuote = 0.0363;
double d6mQuote = 0.0353;
double d9mQuote = 0.0348;
double d1yQuote = 0.0345;
// FRAs
double fra3x6Quote = 0.037125;
double fra6x9Quote = 0.037125;
double fra6x12Quote = 0.037125;
// futures
double fut1Quote = 96.2875;
double fut2Quote = 96.7875;
double fut3Quote = 96.9875;
double fut4Quote = 96.6875;
double fut5Quote = 96.4875;
double fut6Quote = 96.3875;
double fut7Quote = 96.2875;
double fut8Quote = 96.0875;
// swaps
double s2yQuote = 0.037125;
double s3yQuote = 0.0398;
double s5yQuote = 0.0443;
double s10yQuote = 0.05165;
double s15yQuote = 0.055175;
/********************
*** QUOTES ***
********************/
// SimpleQuote stores a value which can be manually changed;
// other Quote subclasses could read the value from a database
// or some kind of data feed.
// deposits
Quote d1wRate = new SimpleQuote(d1wQuote);
Quote d1mRate = new SimpleQuote(d1mQuote);
Quote d3mRate = new SimpleQuote(d3mQuote);
Quote d6mRate = new SimpleQuote(d6mQuote);
Quote d9mRate = new SimpleQuote(d9mQuote);
Quote d1yRate = new SimpleQuote(d1yQuote);
// FRAs
Quote fra3x6Rate = new SimpleQuote(fra3x6Quote);
Quote fra6x9Rate = new SimpleQuote(fra6x9Quote);
Quote fra6x12Rate = new SimpleQuote(fra6x12Quote);
// futures
Quote fut1Price = new SimpleQuote(fut1Quote);
Quote fut2Price = new SimpleQuote(fut2Quote);
Quote fut3Price = new SimpleQuote(fut3Quote);
Quote fut4Price = new SimpleQuote(fut4Quote);
Quote fut5Price = new SimpleQuote(fut5Quote);
Quote fut6Price = new SimpleQuote(fut6Quote);
Quote fut7Price = new SimpleQuote(fut7Quote);
Quote fut8Price = new SimpleQuote(fut8Quote);
// swaps
Quote s2yRate = new SimpleQuote(s2yQuote);
Quote s3yRate = new SimpleQuote(s3yQuote);
Quote s5yRate = new SimpleQuote(s5yQuote);
Quote s10yRate = new SimpleQuote(s10yQuote);
Quote s15yRate = new SimpleQuote(s15yQuote);
/*********************
*** RATE HELPERS ***
*********************/
// RateHelpers are built from the above quotes together with
// other instrument dependant infos. Quotes are passed in
// relinkable handles which could be relinked to some other
// data source later.
// deposits
DayCounter depositDayCounter = new Actual360();
RateHelper d1w = new DepositRateHelper(new Handle<Quote>(d1wRate), new Period(1, TimeUnit.Weeks),
fixingDays, calendar, BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper d1m = new DepositRateHelper(new Handle<Quote>(d1mRate), new Period(1, TimeUnit.Months),
fixingDays, calendar, BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper d3m = new DepositRateHelper(new Handle<Quote>(d3mRate), new Period(3, TimeUnit.Months),
fixingDays, calendar, BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper d6m = new DepositRateHelper(new Handle<Quote>(d6mRate), new Period(6, TimeUnit.Months),
fixingDays, calendar, BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper d9m = new DepositRateHelper(new Handle<Quote>(d9mRate), new Period(9, TimeUnit.Months),
fixingDays, calendar, BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper d1y = new DepositRateHelper(new Handle<Quote>(d1yRate), new Period(1, TimeUnit.Years),
fixingDays, calendar, BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
// setup FRAs
RateHelper fra3x6 = new FraRateHelper(new Handle<Quote>(fra3x6Rate), 3, 6, fixingDays, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper fra6x9 = new FraRateHelper(new Handle<Quote>(fra6x9Rate), 6, 9, fixingDays, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
RateHelper fra6x12 = new FraRateHelper(new Handle<Quote>(fra6x12Rate), 6, 12, fixingDays, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
// setup futures
// Handle<Quote> convexityAdjustment = new Handle<Quote>(new SimpleQuote(0.0));
int futMonths = 3;
Date imm = IMM.nextDate(settlementDate);
RateHelper fut1 = new FuturesRateHelper(new Handle<Quote>(fut1Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut2 = new FuturesRateHelper(new Handle<Quote>(fut2Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut3 = new FuturesRateHelper(new Handle<Quote>(fut3Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut4 = new FuturesRateHelper(new Handle<Quote>(fut4Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut5 = new FuturesRateHelper(new Handle<Quote>(fut5Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut6 = new FuturesRateHelper(new Handle<Quote>(fut6Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut7 = new FuturesRateHelper(new Handle<Quote>(fut7Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
imm = IMM.nextDate(imm + 1);
RateHelper fut8 = new FuturesRateHelper(new Handle<Quote>(fut8Price), imm, futMonths, calendar,
BusinessDayConvention.ModifiedFollowing, true, depositDayCounter);
// setup swaps
Frequency swFixedLegFrequency = Frequency.Annual;
BusinessDayConvention swFixedLegConvention = BusinessDayConvention.Unadjusted;
DayCounter swFixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.European);
IborIndex swFloatingLegIndex = new Euribor6M();
RateHelper s2y = new SwapRateHelper(new Handle<Quote>(s2yRate), new Period(2, TimeUnit.Years),
calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex);
RateHelper s3y = new SwapRateHelper(new Handle<Quote>(s3yRate), new Period(3, TimeUnit.Years),
calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex);
RateHelper s5y = new SwapRateHelper(new Handle<Quote>(s5yRate), new Period(5, TimeUnit.Years),
calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex);
RateHelper s10y = new SwapRateHelper(new Handle<Quote>(s10yRate), new Period(10, TimeUnit.Years),
calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex);
RateHelper s15y = new SwapRateHelper(new Handle<Quote>(s15yRate), new Period(15, TimeUnit.Years),
calendar, swFixedLegFrequency, swFixedLegConvention, swFixedLegDayCounter, swFloatingLegIndex);
/*********************
** CURVE BUILDING **
*********************/
// Any DayCounter would be fine.
// ActualActual::ISDA ensures that 30 years is 30.0
DayCounter termStructureDayCounter = new ActualActual(ActualActual.Convention.ISDA);
double tolerance = 1.0e-15;
// A depo-swap curve
List<RateHelper> depoSwapInstruments = new List<RateHelper>();
depoSwapInstruments.Add(d1w);
depoSwapInstruments.Add(d1m);
depoSwapInstruments.Add(d3m);
depoSwapInstruments.Add(d6m);
depoSwapInstruments.Add(d9m);
depoSwapInstruments.Add(d1y);
depoSwapInstruments.Add(s2y);
depoSwapInstruments.Add(s3y);
depoSwapInstruments.Add(s5y);
depoSwapInstruments.Add(s10y);
depoSwapInstruments.Add(s15y);
YieldTermStructure depoSwapTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, depoSwapInstruments, termStructureDayCounter, new List<Handle<Quote>>(), new List<Date>(), tolerance);
// A depo-futures-swap curve
List<RateHelper> depoFutSwapInstruments = new List<RateHelper>();
depoFutSwapInstruments.Add(d1w);
depoFutSwapInstruments.Add(d1m);
depoFutSwapInstruments.Add(fut1);
depoFutSwapInstruments.Add(fut2);
depoFutSwapInstruments.Add(fut3);
depoFutSwapInstruments.Add(fut4);
depoFutSwapInstruments.Add(fut5);
depoFutSwapInstruments.Add(fut6);
depoFutSwapInstruments.Add(fut7);
depoFutSwapInstruments.Add(fut8);
depoFutSwapInstruments.Add(s3y);
depoFutSwapInstruments.Add(s5y);
depoFutSwapInstruments.Add(s10y);
depoFutSwapInstruments.Add(s15y);
YieldTermStructure depoFutSwapTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, depoFutSwapInstruments, termStructureDayCounter, new List<Handle<Quote>>(), new List<Date>(), tolerance);
// A depo-FRA-swap curve
List<RateHelper> depoFRASwapInstruments = new List<RateHelper>();
depoFRASwapInstruments.Add(d1w);
depoFRASwapInstruments.Add(d1m);
depoFRASwapInstruments.Add(d3m);
depoFRASwapInstruments.Add(fra3x6);
depoFRASwapInstruments.Add(fra6x9);
depoFRASwapInstruments.Add(fra6x12);
depoFRASwapInstruments.Add(s2y);
depoFRASwapInstruments.Add(s3y);
depoFRASwapInstruments.Add(s5y);
depoFRASwapInstruments.Add(s10y);
depoFRASwapInstruments.Add(s15y);
YieldTermStructure depoFRASwapTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, depoFRASwapInstruments, termStructureDayCounter, new List<Handle<Quote>>(), new List<Date>(), tolerance);
// Term structures that will be used for pricing:
// the one used for discounting cash flows
RelinkableHandle<YieldTermStructure> discountingTermStructure = new RelinkableHandle<YieldTermStructure>();
// the one used for forward rate forecasting
RelinkableHandle<YieldTermStructure> forecastingTermStructure = new RelinkableHandle<YieldTermStructure>();
/*********************
* SWAPS TO BE PRICED *
**********************/
// constant nominal 1,000,000 Euro
double nominal = 1000000.0;
// fixed leg
Frequency fixedLegFrequency = Frequency.Annual;
BusinessDayConvention fixedLegConvention = BusinessDayConvention.Unadjusted;
BusinessDayConvention floatingLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.European);
double fixedRate = 0.04;
DayCounter floatingLegDayCounter = new Actual360();
// floating leg
Frequency floatingLegFrequency = Frequency.Semiannual;
IborIndex euriborIndex = new Euribor6M(forecastingTermStructure);
double spread = 0.0;
int lenghtInYears = 5;
VanillaSwap.Type swapType = VanillaSwap.Type.Payer;
Date maturity = settlementDate + new Period(lenghtInYears, TimeUnit.Years);
Schedule fixedSchedule = new Schedule(settlementDate, maturity, new Period(fixedLegFrequency),
calendar, fixedLegConvention, fixedLegConvention, DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(settlementDate, maturity, new Period(floatingLegFrequency),
calendar, floatingLegConvention, floatingLegConvention, DateGeneration.Rule.Forward, false);
VanillaSwap spot5YearSwap = new VanillaSwap(swapType, nominal, fixedSchedule, fixedRate, fixedLegDayCounter,
floatSchedule, euriborIndex, spread, floatingLegDayCounter);
Date fwdStart = calendar.advance(settlementDate, 1, TimeUnit.Years);
Date fwdMaturity = fwdStart + new Period(lenghtInYears, TimeUnit.Years);
Schedule fwdFixedSchedule = new Schedule(fwdStart, fwdMaturity, new Period(fixedLegFrequency),
calendar, fixedLegConvention, fixedLegConvention, DateGeneration.Rule.Forward, false);
Schedule fwdFloatSchedule = new Schedule(fwdStart, fwdMaturity, new Period(floatingLegFrequency),
calendar, floatingLegConvention, floatingLegConvention, DateGeneration.Rule.Forward, false);
VanillaSwap oneYearForward5YearSwap = new VanillaSwap(swapType, nominal, fwdFixedSchedule, fixedRate, fixedLegDayCounter,
fwdFloatSchedule, euriborIndex, spread, floatingLegDayCounter);
/***************
* SWAP PRICING *
****************/
// utilities for reporting
List<string> headers = new List<string>();
headers.Add("term structure");
headers.Add("net present value");
headers.Add("fair spread");
headers.Add("fair fixed rate");
string separator = " | ";
int width = headers[0].Length + separator.Length
+ headers[1].Length + separator.Length
+ headers[2].Length + separator.Length
+ headers[3].Length + separator.Length - 1;
string rule = string.Format("").PadLeft(width, '-'), dblrule = string.Format("").PadLeft(width, '=');
string tab = string.Format("").PadLeft(8, ' ');
// calculations
Console.WriteLine(dblrule);
Console.WriteLine("5-year market swap-rate = {0:0.00%}", s5yRate.value());
Console.WriteLine(dblrule);
Console.WriteLine(tab + "5-years swap paying {0:0.00%}", fixedRate);
Console.WriteLine(headers[0] + separator
+ headers[1] + separator
+ headers[2] + separator
+ headers[3] + separator);
Console.WriteLine(rule);
double NPV;
double fairRate;
double fairSpread;
IPricingEngine swapEngine = new DiscountingSwapEngine(discountingTermStructure);
spot5YearSwap.setPricingEngine(swapEngine);
oneYearForward5YearSwap.setPricingEngine(swapEngine);
// Of course, you're not forced to really use different curves
forecastingTermStructure.linkTo(depoSwapTermStructure);
discountingTermStructure.linkTo(depoSwapTermStructure);
NPV = spot5YearSwap.NPV();
fairSpread = spot5YearSwap.fairSpread();
fairRate = spot5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
// let's check that the 5 years swap has been correctly re-priced
if (!(Math.Abs(fairRate-s5yQuote)<1e-8))
throw new ApplicationException("5-years swap mispriced by " + Math.Abs(fairRate-s5yQuote));
forecastingTermStructure.linkTo(depoFutSwapTermStructure);
discountingTermStructure.linkTo(depoFutSwapTermStructure);
NPV = spot5YearSwap.NPV();
fairSpread = spot5YearSwap.fairSpread();
fairRate = spot5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-fut-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
if (!(Math.Abs(fairRate-s5yQuote)<1e-8))
throw new ApplicationException("5-years swap mispriced by " + Math.Abs(fairRate-s5yQuote));
forecastingTermStructure.linkTo(depoFRASwapTermStructure);
discountingTermStructure.linkTo(depoFRASwapTermStructure);
NPV = spot5YearSwap.NPV();
fairSpread = spot5YearSwap.fairSpread();
fairRate = spot5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-FRA-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
if (!(Math.Abs(fairRate-s5yQuote)<1e-8))
throw new ApplicationException("5-years swap mispriced by " + Math.Abs(fairRate-s5yQuote));
Console.WriteLine(rule);
// now let's price the 1Y forward 5Y swap
Console.WriteLine(tab + "5-years, 1-year forward swap paying {0:0.00%}", fixedRate);
Console.WriteLine(headers[0] + separator
+ headers[1] + separator
+ headers[2] + separator
+ headers[3] + separator);
Console.WriteLine(rule);
forecastingTermStructure.linkTo(depoSwapTermStructure);
discountingTermStructure.linkTo(depoSwapTermStructure);
NPV = oneYearForward5YearSwap.NPV();
fairSpread = oneYearForward5YearSwap.fairSpread();
fairRate = oneYearForward5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
forecastingTermStructure.linkTo(depoFutSwapTermStructure);
discountingTermStructure.linkTo(depoFutSwapTermStructure);
NPV = oneYearForward5YearSwap.NPV();
fairSpread = oneYearForward5YearSwap.fairSpread();
fairRate = oneYearForward5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-fut-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
forecastingTermStructure.linkTo(depoFRASwapTermStructure);
discountingTermStructure.linkTo(depoFRASwapTermStructure);
NPV = oneYearForward5YearSwap.NPV();
fairSpread = oneYearForward5YearSwap.fairSpread();
fairRate = oneYearForward5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-FRA-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
// now let's say that the 5-years swap rate goes up to 4.60%.
// A smarter market element--say, connected to a data source-- would
// notice the change itself. Since we're using SimpleQuotes,
// we'll have to change the value manually--which forces us to
// downcast the handle and use the SimpleQuote
// interface. In any case, the point here is that a change in the
// value contained in the Quote triggers a new bootstrapping
// of the curve and a repricing of the swap.
SimpleQuote fiveYearsRate = s5yRate as SimpleQuote;
fiveYearsRate.setValue(0.0460);
Console.WriteLine(dblrule);
Console.WriteLine("5-year market swap-rate = {0:0.00%}", s5yRate.value());
Console.WriteLine(dblrule);
Console.WriteLine(tab + "5-years swap paying {0:0.00%}", fixedRate);
Console.WriteLine(headers[0] + separator
+ headers[1] + separator
+ headers[2] + separator
+ headers[3] + separator);
Console.WriteLine(rule);
// now get the updated results
forecastingTermStructure.linkTo(depoSwapTermStructure);
discountingTermStructure.linkTo(depoSwapTermStructure);
NPV = spot5YearSwap.NPV();
fairSpread = spot5YearSwap.fairSpread();
fairRate = spot5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
if (!(Math.Abs(fairRate-s5yRate.value())<1e-8))
throw new ApplicationException("5-years swap mispriced by " + Math.Abs(fairRate-s5yRate.value()));
forecastingTermStructure.linkTo(depoFutSwapTermStructure);
discountingTermStructure.linkTo(depoFutSwapTermStructure);
NPV = spot5YearSwap.NPV();
fairSpread = spot5YearSwap.fairSpread();
fairRate = spot5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-fut-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
if (!(Math.Abs(fairRate-s5yRate.value())<1e-8))
throw new ApplicationException("5-years swap mispriced by " + Math.Abs(fairRate-s5yRate.value()));
forecastingTermStructure.linkTo(depoFRASwapTermStructure);
discountingTermStructure.linkTo(depoFRASwapTermStructure);
NPV = spot5YearSwap.NPV();
fairSpread = spot5YearSwap.fairSpread();
fairRate = spot5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-FRA-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
if (!(Math.Abs(fairRate-s5yRate.value())<1e-8))
throw new ApplicationException("5-years swap mispriced by " + Math.Abs(fairRate-s5yRate.value()));
Console.WriteLine(rule);
// the 1Y forward 5Y swap changes as well
Console.WriteLine(tab + "5-years, 1-year forward swap paying {0:0.00%}", fixedRate);
Console.WriteLine(headers[0] + separator
+ headers[1] + separator
+ headers[2] + separator
+ headers[3] + separator);
Console.WriteLine(rule);
forecastingTermStructure.linkTo(depoSwapTermStructure);
discountingTermStructure.linkTo(depoSwapTermStructure);
NPV = oneYearForward5YearSwap.NPV();
fairSpread = oneYearForward5YearSwap.fairSpread();
fairRate = oneYearForward5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
forecastingTermStructure.linkTo(depoFutSwapTermStructure);
discountingTermStructure.linkTo(depoFutSwapTermStructure);
NPV = oneYearForward5YearSwap.NPV();
fairSpread = oneYearForward5YearSwap.fairSpread();
fairRate = oneYearForward5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-fut-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
forecastingTermStructure.linkTo(depoFRASwapTermStructure);
discountingTermStructure.linkTo(depoFRASwapTermStructure);
NPV = oneYearForward5YearSwap.NPV();
fairSpread = oneYearForward5YearSwap.fairSpread();
fairRate = oneYearForward5YearSwap.fairRate();
Console.Write("{0," + headers[0].Length + ":0.00}" + separator, "depo-FRA-swap");
Console.Write("{0," + headers[1].Length + ":0.00}" + separator, NPV);
Console.Write("{0," + headers[2].Length + ":0.00%}" + separator, fairSpread);
Console.WriteLine("{0," + headers[3].Length + ":0.00%}" + separator, fairRate);
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
static void Main(string[] args) {
DateTime timer = DateTime.Now;
/*********************
*** MARKET DATA ***
*********************/
Calendar calendar = new TARGET();
Date settlementDate = new Date(18, Month.September, 2008);
// must be a business day
settlementDate = calendar.adjust(settlementDate);
int fixingDays = 3;
int settlementDays = 3;
Date todaysDate = calendar.advance(settlementDate, -fixingDays, TimeUnit.Days);
// nothing to do with Date::todaysDate
Settings.setEvaluationDate(todaysDate);
Console.WriteLine("Today: {0}, {1}", todaysDate.DayOfWeek, todaysDate);
Console.WriteLine("Settlement date: {0}, {1}", settlementDate.DayOfWeek, settlementDate);
// Building of the bonds discounting yield curve
/*********************
*** RATE HELPERS ***
*********************/
// RateHelpers are built from the above quotes together with
// other instrument dependant infos. Quotes are passed in
// relinkable handles which could be relinked to some other
// data source later.
// Common data
// ZC rates for the short end
double zc3mQuote=0.0096;
double zc6mQuote=0.0145;
double zc1yQuote=0.0194;
Quote zc3mRate = new SimpleQuote(zc3mQuote);
Quote zc6mRate = new SimpleQuote(zc6mQuote);
Quote zc1yRate = new SimpleQuote(zc1yQuote);
DayCounter zcBondsDayCounter = new Actual365Fixed();
RateHelper zc3m = new DepositRateHelper(new Handle<Quote>(zc3mRate),
new Period(3, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, zcBondsDayCounter);
RateHelper zc6m = new DepositRateHelper(new Handle<Quote>(zc6mRate),
new Period(6, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, zcBondsDayCounter);
RateHelper zc1y = new DepositRateHelper(new Handle<Quote>(zc1yRate),
new Period(1, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, zcBondsDayCounter);
// setup bonds
double redemption = 100.0;
const int numberOfBonds = 5;
Date[] issueDates = {
new Date (15, Month.March, 2005),
new Date (15, Month.June, 2005),
new Date (30, Month.June, 2006),
new Date (15, Month.November, 2002),
new Date (15, Month.May, 1987)
};
Date[] maturities = {
new Date (31, Month.August, 2010),
new Date (31, Month.August, 2011),
new Date (31, Month.August, 2013),
new Date (15, Month.August, 2018),
new Date (15, Month.May, 2038)
};
double[] couponRates = {
0.02375,
0.04625,
0.03125,
0.04000,
0.04500
};
double[] marketQuotes = {
100.390625,
106.21875,
100.59375,
101.6875,
102.140625
};
List<SimpleQuote> quote = new List<SimpleQuote>();
for (int i=0; i<numberOfBonds; i++) {
SimpleQuote cp = new SimpleQuote(marketQuotes[i]);
quote.Add(cp);
}
List<RelinkableHandle<Quote>> quoteHandle = new InitializedList<RelinkableHandle<Quote>>(numberOfBonds);
for (int i=0; i<numberOfBonds; i++) {
quoteHandle[i].linkTo(quote[i]);
}
// Definition of the rate helpers
List<FixedRateBondHelper> bondsHelpers = new List<FixedRateBondHelper>();
for (int i=0; i<numberOfBonds; i++) {
Schedule schedule = new Schedule(issueDates[i], maturities[i], new Period(Frequency.Semiannual),
new UnitedStates(UnitedStates.Market.GovernmentBond),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
DateGeneration.Rule.Backward, false);
FixedRateBondHelper bondHelper = new FixedRateBondHelper(quoteHandle[i],
settlementDays,
100.0,
schedule,
new List<double>() { couponRates[i] },
new ActualActual(ActualActual.Convention.Bond),
BusinessDayConvention.Unadjusted,
redemption,
issueDates[i]);
bondsHelpers.Add(bondHelper);
}
/*********************
** CURVE BUILDING **
*********************/
// Any DayCounter would be fine.
// ActualActual::ISDA ensures that 30 years is 30.0
DayCounter termStructureDayCounter = new ActualActual(ActualActual.Convention.ISDA);
double tolerance = 1.0e-15;
// A depo-bond curve
List<RateHelper> bondInstruments = new List<RateHelper>();
// Adding the ZC bonds to the curve for the short end
bondInstruments.Add(zc3m);
bondInstruments.Add(zc6m);
bondInstruments.Add(zc1y);
// Adding the Fixed rate bonds to the curve for the long end
for (int i=0; i<numberOfBonds; i++) {
bondInstruments.Add(bondsHelpers[i]);
}
YieldTermStructure bondDiscountingTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, bondInstruments,
termStructureDayCounter,
new List<Handle<Quote>>(),
new List<Date>(),
tolerance);
// Building of the Libor forecasting curve
// deposits
double d1wQuote=0.043375;
double d1mQuote=0.031875;
double d3mQuote=0.0320375;
double d6mQuote=0.03385;
double d9mQuote=0.0338125;
double d1yQuote=0.0335125;
// swaps
double s2yQuote=0.0295;
double s3yQuote=0.0323;
double s5yQuote=0.0359;
double s10yQuote=0.0412;
double s15yQuote=0.0433;
/********************
*** QUOTES ***
********************/
// SimpleQuote stores a value which can be manually changed;
// other Quote subclasses could read the value from a database
// or some kind of data feed.
// deposits
Quote d1wRate = new SimpleQuote(d1wQuote);
Quote d1mRate = new SimpleQuote(d1mQuote);
Quote d3mRate = new SimpleQuote(d3mQuote);
Quote d6mRate = new SimpleQuote(d6mQuote);
Quote d9mRate = new SimpleQuote(d9mQuote);
Quote d1yRate = new SimpleQuote(d1yQuote);
// swaps
Quote s2yRate = new SimpleQuote(s2yQuote);
Quote s3yRate = new SimpleQuote(s3yQuote);
Quote s5yRate = new SimpleQuote(s5yQuote);
Quote s10yRate = new SimpleQuote(s10yQuote);
Quote s15yRate = new SimpleQuote(s15yQuote);
/*********************
*** RATE HELPERS ***
*********************/
// RateHelpers are built from the above quotes together with
// other instrument dependant infos. Quotes are passed in
// relinkable handles which could be relinked to some other
// data source later.
// deposits
DayCounter depositDayCounter = new Actual360();
RateHelper d1w = new DepositRateHelper(
new Handle<Quote>(d1wRate),
new Period(1, TimeUnit.Weeks), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d1m = new DepositRateHelper(
new Handle<Quote>(d1mRate),
new Period(1, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d3m = new DepositRateHelper(
new Handle<Quote>(d3mRate),
new Period(3, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d6m = new DepositRateHelper(
new Handle<Quote>(d6mRate),
new Period(6, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d9m = new DepositRateHelper(
new Handle<Quote>(d9mRate),
new Period(9, TimeUnit.Months), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
RateHelper d1y = new DepositRateHelper(
new Handle<Quote>(d1yRate),
new Period(1, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing,
true, depositDayCounter);
// setup swaps
Frequency swFixedLegFrequency =Frequency.Annual;
BusinessDayConvention swFixedLegConvention = BusinessDayConvention.Unadjusted;
DayCounter swFixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.European);
IborIndex swFloatingLegIndex = new Euribor6M();
Period forwardStart = new Period(1, TimeUnit.Days);
RateHelper s2y = new SwapRateHelper(
new Handle<Quote>(s2yRate), new Period(2, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s3y = new SwapRateHelper(
new Handle<Quote>(s3yRate), new Period(3, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s5y = new SwapRateHelper(
new Handle<Quote>(s5yRate), new Period(5, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s10y = new SwapRateHelper(
new Handle<Quote>(s10yRate), new Period(10, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
RateHelper s15y = new SwapRateHelper(
new Handle<Quote>(s15yRate), new Period(15, TimeUnit.Years),
calendar, swFixedLegFrequency,
swFixedLegConvention, swFixedLegDayCounter,
swFloatingLegIndex, new Handle<Quote>(),forwardStart);
/*********************
** CURVE BUILDING **
*********************/
// Any DayCounter would be fine.
// ActualActual::ISDA ensures that 30 years is 30.0
// A depo-swap curve
List<RateHelper> depoSwapInstruments = new List<RateHelper>();
depoSwapInstruments.Add(d1w);
depoSwapInstruments.Add(d1m);
depoSwapInstruments.Add(d3m);
depoSwapInstruments.Add(d6m);
depoSwapInstruments.Add(d9m);
depoSwapInstruments.Add(d1y);
depoSwapInstruments.Add(s2y);
depoSwapInstruments.Add(s3y);
depoSwapInstruments.Add(s5y);
depoSwapInstruments.Add(s10y);
depoSwapInstruments.Add(s15y);
YieldTermStructure depoSwapTermStructure = new PiecewiseYieldCurve<Discount,LogLinear>(
settlementDate, depoSwapInstruments,
termStructureDayCounter,
new List<Handle<Quote> >(),
new List<Date>(),
tolerance);
// Term structures that will be used for pricing:
// the one used for discounting cash flows
RelinkableHandle<YieldTermStructure> discountingTermStructure = new RelinkableHandle<YieldTermStructure>();
// the one used for forward rate forecasting
RelinkableHandle<YieldTermStructure> forecastingTermStructure = new RelinkableHandle<YieldTermStructure>();
/*********************
* BONDS TO BE PRICED *
**********************/
// Common data
double faceAmount = 100;
// Pricing engine
IPricingEngine bondEngine = new DiscountingBondEngine(discountingTermStructure);
// Zero coupon bond
ZeroCouponBond zeroCouponBond = new ZeroCouponBond(
settlementDays,
new UnitedStates(UnitedStates.Market.GovernmentBond),
faceAmount,
new Date(15, Month.August,2013),
BusinessDayConvention.Following,
116.92,
new Date(15, Month.August,2003));
zeroCouponBond.setPricingEngine(bondEngine);
// Fixed 4.5% US Treasury Note
Schedule fixedBondSchedule = new Schedule(new Date(15, Month.May, 2007),
new Date(15,Month.May,2017), new Period(Frequency.Semiannual),
new UnitedStates(UnitedStates.Market.GovernmentBond),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, false);
FixedRateBond fixedRateBond = new FixedRateBond(
settlementDays,
faceAmount,
fixedBondSchedule,
new List<double>() { 0.045 },
new ActualActual(ActualActual.Convention.Bond),
BusinessDayConvention.ModifiedFollowing,
100.0, new Date(15, Month.May, 2007));
fixedRateBond.setPricingEngine(bondEngine);
// Floating rate bond (3M USD Libor + 0.1%)
// Should and will be priced on another curve later...
RelinkableHandle<YieldTermStructure> liborTermStructure = new RelinkableHandle<YieldTermStructure>();
IborIndex libor3m = new USDLibor(new Period(3, TimeUnit.Months), liborTermStructure);
libor3m.addFixing(new Date(17, Month.July, 2008),0.0278625);
Schedule floatingBondSchedule = new Schedule(new Date(21, Month.October, 2005),
new Date(21, Month.October, 2010), new Period(Frequency.Quarterly),
new UnitedStates(UnitedStates.Market.NYSE),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, true);
FloatingRateBond floatingRateBond = new FloatingRateBond(
settlementDays,
faceAmount,
floatingBondSchedule,
libor3m,
new Actual360(),
BusinessDayConvention.ModifiedFollowing,
2,
// Gearings
new List<double>() { 1.0 },
// Spreads
new List<double>() { 0.001 },
// Caps
new List<double>(),
// Floors
new List<double>(),
// Fixing in arrears
true,
100.0,
new Date(21, Month.October, 2005));
floatingRateBond.setPricingEngine(bondEngine);
// Coupon pricers
IborCouponPricer pricer = new BlackIborCouponPricer();
// optionLet volatilities
double volatility = 0.0;
Handle<OptionletVolatilityStructure> vol;
vol = new Handle<OptionletVolatilityStructure>(
new ConstantOptionletVolatility(
settlementDays,
calendar,
BusinessDayConvention.ModifiedFollowing,
volatility,
new Actual365Fixed()));
pricer.setCapletVolatility(vol);
Utils.setCouponPricer(floatingRateBond.cashflows(),pricer);
// Yield curve bootstrapping
forecastingTermStructure.linkTo(depoSwapTermStructure);
discountingTermStructure.linkTo(bondDiscountingTermStructure);
// We are using the depo & swap curve to estimate the future Libor rates
liborTermStructure.linkTo(depoSwapTermStructure);
/***************
* BOND PRICING *
****************/
// write column headings
int[] widths = { 18, 10, 10, 10 };
Console.WriteLine("{0,18}{1,10}{2,10}{3,10}", "", "ZC", "Fixed", "Floating");
string separator = " | ";
int width = widths[0]
+ widths[1]
+ widths[2]
+ widths[3];
string rule = "".PadLeft(width, '-'), dblrule = "".PadLeft(width, '=');
string tab = "".PadLeft(8, ' ');
Console.WriteLine(rule);
Console.WriteLine("Net present value".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.NPV(),
fixedRateBond.NPV(),
floatingRateBond.NPV());
Console.WriteLine("Clean price".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.cleanPrice(),
fixedRateBond.cleanPrice(),
floatingRateBond.cleanPrice());
Console.WriteLine("Dirty price".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.dirtyPrice(),
fixedRateBond.dirtyPrice(),
floatingRateBond.dirtyPrice());
Console.WriteLine("Accrued coupon".PadLeft(widths[0]) + "{0,10:n2}{1,10:n2}{2,10:n2}",
zeroCouponBond.accruedAmount(),
fixedRateBond.accruedAmount(),
floatingRateBond.accruedAmount());
Console.WriteLine("Previous coupon".PadLeft(widths[0]) + "{0,10:0.00%}{1,10:0.00%}{2,10:0.00%}",
"N/A",
fixedRateBond.previousCoupon(),
floatingRateBond.previousCoupon());
Console.WriteLine("Next coupon".PadLeft(widths[0]) + "{0,10:0.00%}{1,10:0.00%}{2,10:0.00%}",
"N/A",
fixedRateBond.nextCoupon(),
floatingRateBond.nextCoupon());
Console.WriteLine("Yield".PadLeft(widths[0]) + "{0,10:0.00%}{1,10:0.00%}{2,10:0.00%}",
zeroCouponBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual),
fixedRateBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual),
floatingRateBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual));
Console.WriteLine();
// Other computations
Console.WriteLine("Sample indirect computations (for the floating rate bond): ");
Console.WriteLine(rule);
Console.WriteLine("Yield to Clean Price: {0:n2}",
floatingRateBond.cleanPrice(floatingRateBond.yield(new Actual360(), Compounding.Compounded, Frequency.Annual),
new Actual360(), Compounding.Compounded, Frequency.Annual,
settlementDate));
Console.WriteLine("Clean Price to Yield: {0:0.00%}",
floatingRateBond.yield(floatingRateBond.cleanPrice(),new Actual360(), Compounding.Compounded, Frequency.Annual,
settlementDate));
/* "Yield to Price"
"Price to Yield" */
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
public void testBootstrap()
{
// Testing Eonia-swap curve building...
CommonVars vars = new CommonVars();
List<RateHelper> eoniaHelpers = new List<RateHelper>();
List<RateHelper> swap3mHelpers = new List<RateHelper>();
IborIndex euribor3m = new Euribor3M();
Eonia eonia = new Eonia();
for (int i = 0; i < depositData.Length; i++)
{
double rate = 0.01 * depositData[i].rate;
SimpleQuote simple = new SimpleQuote(rate);
Handle<Quote> quote = new Handle<Quote>(simple);
Period term = new Period(depositData[i].n , depositData[i].unit);
RateHelper helper = new DepositRateHelper(quote,
term,
depositData[i].settlementDays,
euribor3m.fixingCalendar(),
euribor3m.businessDayConvention(),
euribor3m.endOfMonth(),
euribor3m.dayCounter());
if (term <= new Period(2,TimeUnit.Days))
eoniaHelpers.Add(helper);
if (term <= new Period(3,TimeUnit.Months))
swap3mHelpers.Add(helper);
}
for (int i = 0; i < fraData.Length; i++)
{
double rate = 0.01 * fraData[i].rate;
SimpleQuote simple = new SimpleQuote(rate);
Handle<Quote> quote = new Handle<Quote>(simple);
RateHelper helper = new FraRateHelper(quote,
fraData[i].nExpiry,
fraData[i].nMaturity,
fraData[i].settlementDays,
euribor3m.fixingCalendar(),
euribor3m.businessDayConvention(),
euribor3m.endOfMonth(),
euribor3m.dayCounter());
swap3mHelpers.Add(helper);
}
for (int i = 0; i < eoniaSwapData.Length; i++)
{
double rate = 0.01 * eoniaSwapData[i].rate;
SimpleQuote simple = new SimpleQuote(rate);
Handle<Quote> quote = new Handle<Quote>(simple);
Period term = new Period(eoniaSwapData[i].n , eoniaSwapData[i].unit);
RateHelper helper = new OISRateHelper(eoniaSwapData[i].settlementDays,
term,
quote,
eonia);
eoniaHelpers.Add(helper);
}
for (int i = 0; i < swapData.Length; i++)
{
double rate = 0.01 * swapData[i].rate;
SimpleQuote simple = new SimpleQuote(rate);
Handle<Quote> quote = new Handle<Quote>(simple);
Period tenor = new Period(swapData[i].nIndexUnits , swapData[i].indexUnit);
Period term = new Period(swapData[i].nTermUnits , swapData[i].termUnit);
RateHelper helper = new SwapRateHelper(quote,
term,
vars.calendar,
vars.fixedSwapFrequency,
vars.fixedSwapConvention,
vars.fixedSwapDayCount,
euribor3m);
if (tenor == new Period(3,TimeUnit.Months))
swap3mHelpers.Add(helper);
}
PiecewiseYieldCurve<Discount, LogLinear> eoniaTS = new PiecewiseYieldCurve<Discount, LogLinear>(vars.today,
eoniaHelpers,
new Actual365Fixed());
PiecewiseYieldCurve<Discount, LogLinear> swapTS = new PiecewiseYieldCurve<Discount, LogLinear>(vars.today,
swap3mHelpers,
new Actual365Fixed());
vars.eoniaTermStructure.linkTo(eoniaTS);
// test curve consistency
double tolerance = 1.0e-10;
for (int i = 0; i < eoniaSwapData.Length; i++)
{
double expected = eoniaSwapData[i].rate;
Period term = new Period(eoniaSwapData[i].n , eoniaSwapData[i].unit);
OvernightIndexedSwap swap = vars.makeSwap(term, 0.0, 0.0);
double? calculated = 100.0 * swap.fairRate();
if (Math.Abs(expected-calculated.Value) > tolerance)
Assert.Fail("curve inconsistency:\n"
+ " swap length: " + term + "\n"
+ " quoted rate: " + expected + "\n"
+ " calculated rate: " + calculated);
}
}