public BootstrapError(PiecewiseYieldCurve curve, RateHelper helper, int segment)
{
curve_ = curve;
helper_ = helper;
segment_ = segment;
}
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)
{
QAssert.Fail("curve inconsistency:\n"
+ " swap length: " + term + "\n"
+ " quoted rate: " + expected + "\n"
+ " calculated rate: " + calculated);
}
}
}
static void Main(string[] args)
{
DateTime timer = DateTime.Now;
// set up dates ////////////////////////////////////////
Calendar calendar = new TARGET();
Date todaysDate = new Date(15, Month.January, 2017);
Date settlementDate = new Date(todaysDate);
Settings.setEvaluationDate(todaysDate);
DayCounter dayCounter = new Actual365Fixed();
// Build Rate Curve /////////////////////////////////////
double zc1yRate = 0.002585;
double zc2yRate = 0.005034;
double zc3yRate = 0.008981;
double zc4yRate = 0.012954;
double zc5yRate = 0.016452;
double zc7yRate = 0.021811;
double zc10yRate = 0.027007;
double zc15yRate = 0.031718;
double zc20yRate = 0.033834;
double zc30yRate = 0.035056;
DayCounter zcBondsDayCounter = new Actual365Fixed();
int fixingDays = 0;
RateHelper zc1y = new DepositRateHelper(zc1yRate, new Period(1, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc2y = new DepositRateHelper(zc2yRate, new Period(2, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc3y = new DepositRateHelper(zc3yRate, new Period(3, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc4y = new DepositRateHelper(zc4yRate, new Period(4, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc5y = new DepositRateHelper(zc5yRate, new Period(5, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc7y = new DepositRateHelper(zc7yRate, new Period(7, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc10y = new DepositRateHelper(zc10yRate, new Period(10, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc15y = new DepositRateHelper(zc15yRate, new Period(15, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc20y = new DepositRateHelper(zc20yRate, new Period(20, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
RateHelper zc30y = new DepositRateHelper(zc30yRate, new Period(30, TimeUnit.Years), fixingDays,
calendar, BusinessDayConvention.ModifiedFollowing, true, zcBondsDayCounter);
List <RateHelper> zcInstruments = new List <RateHelper>();
zcInstruments.Add(zc1y);
zcInstruments.Add(zc2y);
zcInstruments.Add(zc3y);
zcInstruments.Add(zc4y);
zcInstruments.Add(zc5y);
zcInstruments.Add(zc7y);
zcInstruments.Add(zc10y);
zcInstruments.Add(zc15y);
zcInstruments.Add(zc20y);
zcInstruments.Add(zc30y);
double tolerance = 1.0e-15;
YieldTermStructure zcTermStructure = new PiecewiseYieldCurve <Discount, LogLinear>(
settlementDate, zcInstruments,
zcBondsDayCounter,
new List <Handle <Quote> >(),
new List <Date>(),
tolerance);
Handle <YieldTermStructure> zcTermStructureH = new Handle <YieldTermStructure>(zcTermStructure);
// Build Credit Curve //////////////////////////////////////
CreditDefaultSwapHelper cds1Y = new CreditDefaultSwapHelper(0.0003, new Period(1, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds2Y = new CreditDefaultSwapHelper(0.0009, new Period(2, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds3Y = new CreditDefaultSwapHelper(0.0015, new Period(3, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds4Y = new CreditDefaultSwapHelper(0.0021, new Period(4, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds5Y = new CreditDefaultSwapHelper(0.0028, new Period(5, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds7Y = new CreditDefaultSwapHelper(0.0043, new Period(7, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds10Y = new CreditDefaultSwapHelper(0.0061, new Period(10, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds15Y = new CreditDefaultSwapHelper(0.0063, new Period(15, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds20Y = new CreditDefaultSwapHelper(0.0068, new Period(20, TimeUnit.Years), zcTermStructureH);
CreditDefaultSwapHelper cds30Y = new CreditDefaultSwapHelper(0.0066, new Period(30, TimeUnit.Years), zcTermStructureH);
List <CreditDefaultSwapHelper> cdsInstruments = new List <CreditDefaultSwapHelper>();
cdsInstruments.Add(cds1Y);
cdsInstruments.Add(cds2Y);
cdsInstruments.Add(cds3Y);
cdsInstruments.Add(cds4Y);
cdsInstruments.Add(cds5Y);
cdsInstruments.Add(cds7Y);
cdsInstruments.Add(cds10Y);
cdsInstruments.Add(cds15Y);
cdsInstruments.Add(cds20Y);
cdsInstruments.Add(cds30Y);
DefaultProbabilityTermStructure defaultTS = new PiecewiseHazardRateCurve <HazardRate, BackwardFlat>(
settlementDate,
cdsInstruments,
dayCounter,
new List <Handle <Quote> >(),
new List <Date>(),
tolerance);
Handle <DefaultProbabilityTermStructure> defaultTSH = new Handle <DefaultProbabilityTermStructure>(defaultTS);
Console.WriteLine("Hazard and Discount Term Structures");
Console.WriteLine(" \n");
int width = 12;
Console.Write("{0,-" + width + "}", "Tenor(y)");
Console.Write("{0,-" + width + "}", "Hazard");
Console.WriteLine("{0,-" + width + "}", "Discount");
double[] tenors = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 10.0, 15.0, 20.0 }; // bug to solve : the last date is not in the availabele univers
foreach (double i in tenors)
{
Console.Write("{0,-" + width + ":0.00}", i + "Y");
Console.Write("{0,-" + width + ":0.00%}", defaultTSH.link.hazardRate(i));
Console.WriteLine("{0,-" + width + ":0.00%}", zcTermStructureH.link.discount(i));
}
// End test
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
static void Main(string[] args)
{
double nominal = 575000000;
Date _marketDate;
Date _settlementDate;
Dictionary <string, double> _depositRates;
Dictionary <string, double> _swapRates;
List <RateHelper> _rateHelpers;
Calendar _calendar = new TARGET();
int _fixingDays = 2;
_marketDate = new Date(new DateTime(2015, 12, 17));
Settings.setEvaluationDate(_marketDate);
_depositRates = new Dictionary <string, double>();
_depositRates.Add("1M", 0.0045);
_depositRates.Add("3M", 0.0070);
_depositRates.Add("6M", 0.0090);
_swapRates = new Dictionary <string, double>();
_swapRates.Add("1Y", 0.0080);
_swapRates.Add("2Y", 0.0109);
_swapRates.Add("3Y", 0.0134);
_swapRates.Add("4Y", 0.0153);
_swapRates.Add("5Y", 0.0169);
_swapRates.Add("7Y", 0.0193);
_swapRates.Add("10Y", 0.0218);
_swapRates.Add("30Y", 0.0262);
_rateHelpers = new List <RateHelper>();
foreach (var v in _depositRates)
{
SimpleQuote sq = new SimpleQuote(v.Value);
_rateHelpers.Add(new DepositRateHelper(new Handle <Quote>(sq), new Period(v.Key),
_fixingDays, _calendar, BusinessDayConvention.ModifiedFollowing, true, new Actual360()));
}
foreach (var v in _swapRates)
{
SimpleQuote sq = new SimpleQuote(v.Value);
_rateHelpers.Add(new SwapRateHelper(new Handle <Quote>(sq), new Period(v.Key),
_calendar, Frequency.Semiannual, BusinessDayConvention.Unadjusted,
new Thirty360(Thirty360.Thirty360Convention.USA), new Euribor3M()));
}
_marketDate = _calendar.adjust(_marketDate);
_settlementDate = _calendar.advance(_marketDate, _fixingDays, TimeUnit.Days);
YieldTermStructure yieldTermStructure = new PiecewiseYieldCurve <Discount, LogLinear>(
_settlementDate, _rateHelpers, new ActualActual(ActualActual.Convention.ISDA));
RelinkableHandle <YieldTermStructure> yieldTermStructureHandle = new RelinkableHandle <YieldTermStructure>();
Frequency fixedLegFrequency = Frequency.Semiannual;
BusinessDayConvention fixedLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.USA);
double fixedRate = 0.0144;
Frequency floatLegFrequency = Frequency.Quarterly;
BusinessDayConvention floatLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter floatLegDayCounter = new Actual360();
IborIndex iborIndex = new Euribor3M(yieldTermStructureHandle);
iborIndex.addFixing(new Date(18, Month.Aug, 2015), 0.0033285);
iborIndex.addFixing(new Date(18, Month.Nov, 2015), 0.0036960);
double floatSpread = 0.0;
VanillaSwap.Type swapType = VanillaSwap.Type.Receiver;
Date maturity = new Date(20, Month.Nov, 2018);
Date effective = new Date(20, Month.Nov, 2013);
Schedule fixedSchedule = new Schedule(effective, maturity, new Period(fixedLegFrequency), _calendar, fixedLegConvention, fixedLegConvention, DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(effective, maturity, new Period(floatLegFrequency), _calendar, floatLegConvention, floatLegConvention, DateGeneration.Rule.Forward, false);
VanillaSwap vanillaSwap = new VanillaSwap(swapType, nominal, fixedSchedule, fixedRate, fixedLegDayCounter, floatSchedule, iborIndex, floatSpread, floatLegDayCounter);
InterestRate interestRate = new InterestRate(fixedRate, fixedLegDayCounter, Compounding.Simple, fixedLegFrequency);
List <InterestRate> coupons = new List <InterestRate>();
for (int i = 0; i < fixedSchedule.Count; i++)
{
coupons.Add(interestRate);
}
FixedRateBond fixedBond = new FixedRateBond(_fixingDays, nominal, fixedSchedule, coupons, BusinessDayConvention.ModifiedFollowing);
FloatingRateBond floatBond = new FloatingRateBond(_fixingDays, nominal, floatSchedule, iborIndex, floatLegDayCounter);
IPricingEngine bondPricingEngine = new DiscountingBondEngine(yieldTermStructureHandle);
fixedBond.setPricingEngine(bondPricingEngine);
floatBond.setPricingEngine(bondPricingEngine);
IPricingEngine swapPricingEngine = new DiscountingSwapEngine(yieldTermStructureHandle);
vanillaSwap.setPricingEngine(swapPricingEngine);
yieldTermStructureHandle.linkTo(yieldTermStructure);
double swapNPV = vanillaSwap.NPV();
double swapFixedNPV = vanillaSwap.fixedLegNPV();
double swapFloatNPV = vanillaSwap.floatingLegNPV();
double bondFixedNPV = fixedBond.NPV();
double bondFloatNPV = floatBond.NPV();
int w = (swapType == VanillaSwap.Type.Receiver ? 1 : -1);
double asBondsMarketValue = w * (bondFixedNPV - bondFloatNPV);
double asBondsMarketValueNoAcc = w * (fixedBond.cleanPrice() - floatBond.cleanPrice()) / 100.0 * nominal;
double asBondsAccruedInterest = asBondsMarketValue - asBondsMarketValueNoAcc;
Console.WriteLine("Vanilla Swap Maket Value : {0:N}", swapNPV);
Console.WriteLine("As Bonds Market Value : {0:N}", asBondsMarketValue);
Console.WriteLine("As Bonds Market Value (no acc): {0:N}", asBondsMarketValueNoAcc);
Console.WriteLine("As Bonds Accrued Interest : {0:N}", asBondsAccruedInterest);
Date rollDate = new Date(1, Month.Nov, 2015);
double bondFixedCash = 0;
foreach (CashFlow cf in fixedBond.cashflows())
{
if (cf.date() > rollDate & cf.date() <= _marketDate)
{
bondFixedCash += cf.amount();
}
}
double bondFloatCash = 0;
foreach (CashFlow cf in floatBond.cashflows())
{
if (cf.date() > rollDate & cf.date() <= _marketDate)
{
bondFloatCash += cf.amount();
}
}
double asBondsCash = w * (bondFixedCash - bondFloatCash);
Console.WriteLine("As Bonds Settled Cash : {0:N}", asBondsCash);
}
static void Main()
{
DateTime timer = DateTime.Now;
/*********************
*** MARKET DATA ***
*********************/
RelinkableHandle <YieldTermStructure> euriborTermStructure = new RelinkableHandle <YieldTermStructure>();
IborIndex euribor3m = new Euribor3M(euriborTermStructure);
Date todaysDate = new Date(23, Month.May, 2006);
Settings.setEvaluationDate(todaysDate);
Calendar calendar = euribor3m.fixingCalendar();
int fixingDays = euribor3m.fixingDays();
Date settlementDate = calendar.advance(todaysDate, fixingDays, TimeUnit.Days);
Console.WriteLine("Today: " + todaysDate.DayOfWeek + ", " + todaysDate);
Console.WriteLine("Settlement date: " + settlementDate.DayOfWeek + ", " + settlementDate);
// 3 month term FRA quotes (index refers to monthsToStart)
double[] threeMonthFraQuote = new double[10];
threeMonthFraQuote[1] = 0.030;
threeMonthFraQuote[2] = 0.031;
threeMonthFraQuote[3] = 0.032;
threeMonthFraQuote[6] = 0.033;
threeMonthFraQuote[9] = 0.034;
/********************
*** 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.
// FRAs
SimpleQuote fra1x4Rate = new SimpleQuote(threeMonthFraQuote[1]);
SimpleQuote fra2x5Rate = new SimpleQuote(threeMonthFraQuote[2]);
SimpleQuote fra3x6Rate = new SimpleQuote(threeMonthFraQuote[3]);
SimpleQuote fra6x9Rate = new SimpleQuote(threeMonthFraQuote[6]);
SimpleQuote fra9x12Rate = new SimpleQuote(threeMonthFraQuote[9]);
RelinkableHandle <Quote> h1x4 = new RelinkableHandle <Quote>(); h1x4.linkTo(fra1x4Rate);
RelinkableHandle <Quote> h2x5 = new RelinkableHandle <Quote>(); h2x5.linkTo(fra2x5Rate);
RelinkableHandle <Quote> h3x6 = new RelinkableHandle <Quote>(); h3x6.linkTo(fra3x6Rate);
RelinkableHandle <Quote> h6x9 = new RelinkableHandle <Quote>(); h6x9.linkTo(fra6x9Rate);
RelinkableHandle <Quote> h9x12 = new RelinkableHandle <Quote>(); h9x12.linkTo(fra9x12Rate);
/*********************
*** 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.
DayCounter fraDayCounter = euribor3m.dayCounter();
BusinessDayConvention convention = euribor3m.businessDayConvention();
bool endOfMonth = euribor3m.endOfMonth();
RateHelper fra1x4 = new FraRateHelper(h1x4, 1, 4,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra2x5 = new FraRateHelper(h2x5, 2, 5,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra3x6 = new FraRateHelper(h3x6, 3, 6,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra6x9 = new FraRateHelper(h6x9, 6, 9,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
RateHelper fra9x12 = new FraRateHelper(h9x12, 9, 12,
fixingDays, calendar, convention,
endOfMonth, fraDayCounter);
/*********************
** 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 FRA curve
List <RateHelper> fraInstruments = new List <RateHelper>();
fraInstruments.Add(fra1x4);
fraInstruments.Add(fra2x5);
fraInstruments.Add(fra3x6);
fraInstruments.Add(fra6x9);
fraInstruments.Add(fra9x12);
YieldTermStructure fraTermStructure = new PiecewiseYieldCurve <Discount, LogLinear>(
settlementDate, fraInstruments, termStructureDayCounter,
new List <Handle <Quote> >(), new List <Date>(), tolerance);
// Term structures used for pricing/discounting
RelinkableHandle <YieldTermStructure> discountingTermStructure = new RelinkableHandle <YieldTermStructure>();
discountingTermStructure.linkTo(fraTermStructure);
/***********************
*** construct FRA's ***
***********************/
Calendar fraCalendar = euribor3m.fixingCalendar();
BusinessDayConvention fraBusinessDayConvention = euribor3m.businessDayConvention();
Position.Type fraFwdType = Position.Type.Long;
double fraNotional = 100.0;
const int FraTermMonths = 3;
int[] monthsToStart = new [] { 1, 2, 3, 6, 9 };
euriborTermStructure.linkTo(fraTermStructure);
Console.WriteLine("\nTest FRA construction, NPV calculation, and FRA purchase\n");
int i;
for (i = 0; i < monthsToStart.Length; i++)
{
Date fraValueDate = fraCalendar.advance(
settlementDate, monthsToStart[i], TimeUnit.Months,
fraBusinessDayConvention);
Date fraMaturityDate = fraCalendar.advance(
fraValueDate, FraTermMonths, TimeUnit.Months,
fraBusinessDayConvention);
double fraStrikeRate = threeMonthFraQuote[monthsToStart[i]];
ForwardRateAgreement myFRA = new ForwardRateAgreement(fraValueDate, fraMaturityDate,
fraFwdType, fraStrikeRate,
fraNotional, euribor3m,
discountingTermStructure);
Console.WriteLine("3m Term FRA, Months to Start: " + monthsToStart[i]);
Console.WriteLine("strike FRA rate: {0:0.00%}", fraStrikeRate);
Console.WriteLine("FRA 3m forward rate: {0:0.00%}", myFRA.forwardRate());
Console.WriteLine("FRA market quote: {0:0.00%}", threeMonthFraQuote[monthsToStart[i]]);
Console.WriteLine("FRA spot value: " + myFRA.spotValue());
Console.WriteLine("FRA forward value: " + myFRA.forwardValue());
Console.WriteLine("FRA implied Yield: {0:0.00%}",
myFRA.impliedYield(myFRA.spotValue(), myFRA.forwardValue(), settlementDate, Compounding.Simple, fraDayCounter));
Console.WriteLine("market Zero Rate: {0:0.00%}",
discountingTermStructure.link.zeroRate(fraMaturityDate, fraDayCounter, Compounding.Simple));
Console.WriteLine("FRA NPV [should be zero]: {0}\n", myFRA.NPV());
}
Console.WriteLine("\n");
Console.WriteLine("Now take a 100 basis-point upward shift in FRA quotes and examine NPV\n");
const double BpsShift = 0.01;
threeMonthFraQuote[1] = 0.030 + BpsShift;
threeMonthFraQuote[2] = 0.031 + BpsShift;
threeMonthFraQuote[3] = 0.032 + BpsShift;
threeMonthFraQuote[6] = 0.033 + BpsShift;
threeMonthFraQuote[9] = 0.034 + BpsShift;
fra1x4Rate.setValue(threeMonthFraQuote[1]);
fra2x5Rate.setValue(threeMonthFraQuote[2]);
fra3x6Rate.setValue(threeMonthFraQuote[3]);
fra6x9Rate.setValue(threeMonthFraQuote[6]);
fra9x12Rate.setValue(threeMonthFraQuote[9]);
for (i = 0; i < monthsToStart.Length; i++)
{
Date fraValueDate = fraCalendar.advance(
settlementDate, monthsToStart[i], TimeUnit.Months,
fraBusinessDayConvention);
Date fraMaturityDate = fraCalendar.advance(
fraValueDate, FraTermMonths, TimeUnit.Months,
fraBusinessDayConvention);
double fraStrikeRate = threeMonthFraQuote[monthsToStart[i]] - BpsShift;
ForwardRateAgreement myFRA = new ForwardRateAgreement(fraValueDate, fraMaturityDate,
fraFwdType, fraStrikeRate,
fraNotional, euribor3m,
discountingTermStructure);
Console.WriteLine("3m Term FRA, 100 notional, Months to Start: " + monthsToStart[i]);
Console.WriteLine("strike FRA rate: {0:0.00%}", fraStrikeRate);
Console.WriteLine("FRA 3m forward rate: {0:0.00%}", myFRA.forwardRate());
Console.WriteLine("FRA market quote: {0:0.00%}", threeMonthFraQuote[monthsToStart[i]]);
Console.WriteLine("FRA spot value: " + myFRA.spotValue());
Console.WriteLine("FRA forward value: " + myFRA.forwardValue());
Console.WriteLine("FRA implied Yield: {0:0.00%}",
myFRA.impliedYield(myFRA.spotValue(), myFRA.forwardValue(), settlementDate, Compounding.Simple, fraDayCounter));
Console.WriteLine("market Zero Rate: {0:0.00%}",
discountingTermStructure.link.zeroRate(fraMaturityDate, fraDayCounter, Compounding.Simple));
Console.WriteLine("FRA NPV [should be positive]: {0}\n", myFRA.NPV());
}
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
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();
}
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();
}
public BootstrapError(PiecewiseYieldCurve curve, RateHelper helper, int segment)
{
_curve = curve;
_helper = helper;
_segment = segment;
}
public BootstrapError(PiecewiseYieldCurve curve, RateHelper helper, int segment)
{
_curve = curve;
_helper = helper;
_segment = segment;
}
private YieldTermStructure Piecewisecurve(List <RateHelper> instruments)
{
YieldTermStructure yieldts; // = FastActivator<PiecewiseYieldCurve>.Create();
switch (_interpolationVariable)
{
case InterpolationVariable.Zero:
switch (_interpolationMethod)
{
case InterpolationMethod.Linear:
yieldts = new PiecewiseYieldCurve <ZeroYield, Linear>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
case InterpolationMethod.LogLinear:
yieldts = new PiecewiseYieldCurve <ZeroYield, LogLinear>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
case InterpolationMethod.NaturalCubic:
yieldts = new PiecewiseYieldCurve <ZeroYield, Cubic>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy,
new Cubic(CubicInterpolation.DerivativeApprox.Kruger, true, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0));
break;
case InterpolationMethod.FinancialCubic:
yieldts = new PiecewiseYieldCurve <ZeroYield, Cubic>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy,
new Cubic(CubicInterpolation.DerivativeApprox.Kruger, true, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0));
break;
case InterpolationMethod.ConvexMonotone:
yieldts = new PiecewiseYieldCurve <ZeroYield, ConvexMonotone>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
default:
Utils.QL_FAIL("Interpolation method not recognised.");
throw new Exception();
}
break;
case InterpolationVariable.Discount:
switch (_interpolationMethod)
{
case InterpolationMethod.Linear:
yieldts = new PiecewiseYieldCurve <Discount, Linear>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
case InterpolationMethod.LogLinear:
yieldts = new PiecewiseYieldCurve <Discount, LogLinear>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
case InterpolationMethod.NaturalCubic:
yieldts = new PiecewiseYieldCurve <Discount, Cubic>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy, new Cubic(CubicInterpolation.DerivativeApprox.Kruger, true, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0));
break;
case InterpolationMethod.FinancialCubic:
yieldts = new PiecewiseYieldCurve <Discount, Cubic>(
_asofDate, instruments, _zeroDayCounter, null, null, _accuracy,
new Cubic(CubicInterpolation.DerivativeApprox.Kruger, true, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0, CubicInterpolation.BoundaryCondition.FirstDerivative, 0.0));
break;
case InterpolationMethod.ConvexMonotone:
yieldts = new PiecewiseYieldCurve <Discount, ConvexMonotone>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
default:
Utils.QL_FAIL("Interpolation method not recognised.");
throw new Exception();
}
break;
case InterpolationVariable.Forward:
switch (_interpolationMethod)
{
case InterpolationMethod.Linear:
yieldts = new PiecewiseYieldCurve <ForwardRate, Linear>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
case InterpolationMethod.LogLinear:
yieldts = new PiecewiseYieldCurve <ForwardRate, LogLinear>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
case InterpolationMethod.NaturalCubic:
yieldts = new PiecewiseYieldCurve <ForwardRate, Cubic>(
_asofDate, instruments, _zeroDayCounter, null, null, _accuracy,
new Cubic(CubicInterpolation.DerivativeApprox.Kruger, true, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0));
break;
case InterpolationMethod.FinancialCubic:
yieldts = new PiecewiseYieldCurve <ForwardRate, Cubic>(
_asofDate, instruments, _zeroDayCounter, null, null, _accuracy,
new Cubic(CubicInterpolation.DerivativeApprox.Kruger, true, CubicInterpolation.BoundaryCondition.SecondDerivative, 0.0, CubicInterpolation.BoundaryCondition.FirstDerivative, 0.0));
break;
case InterpolationMethod.ConvexMonotone:
yieldts = new PiecewiseYieldCurve <ForwardRate, ConvexMonotone>(_asofDate, instruments, _zeroDayCounter, null, null, _accuracy);
break;
default:
Utils.QL_FAIL("Interpolation method not recognised.");
throw new Exception();
}
break;
default:
Utils.QL_FAIL("Interpolation variable not recognised.");
throw new Exception();
}
// Build fixed zero/discount curve that matches the boostrapped curve
// initially, but does NOT react to quote changes: This is a workaround
// for a QuantLib problem, where a fixed reference date piecewise
// yield curve reacts to evaluation date changes because the bootstrap
// helper recompute their start date (because they are realtive date
// helper for deposits, fras, swaps, etc.).
InitializedList <Date> dates = new InitializedList <Date>(instruments.Count + 1, _asofDate);
InitializedList <double> zeros = new InitializedList <double>(instruments.Count + 1, 0.0);
InitializedList <double> discounts = new InitializedList <double>(instruments.Count + 1, 1.0);
InitializedList <double> forwards = new InitializedList <double>(instruments.Count + 1, 0.0);
if (_extrapolation)
{
yieldts.enableExtrapolation();
}
for (int i = 0; i < instruments.Count; i++)
{
dates[i + 1] = instruments[i].latestDate();
zeros[i + 1] = yieldts.zeroRate(dates[i + 1], _zeroDayCounter, Compounding.Continuous).value();
discounts[i + 1] = yieldts.discount(dates[i + 1]);
forwards[i + 1] = yieldts.forwardRate(dates[i + 1], dates[i + 1], _zeroDayCounter, Compounding.Continuous).value();
}
zeros[0] = zeros[1];
forwards[0] = forwards[1];
if (_interpolationVariable == InterpolationVariable.Zero)
{
_p = Zerocurve(dates, zeros, _zeroDayCounter);
}
else if (_interpolationVariable == InterpolationVariable.Discount)
{
_p = Discountcurve(dates, discounts, _zeroDayCounter);
}
else if (_interpolationVariable == InterpolationVariable.Forward)
{
_p = Forwardcurve(dates, forwards, _zeroDayCounter);
}
else
{
Utils.QL_FAIL("Interpolation variable not recognised.");
}
return(_p);
}
