public FloatFloatSwap(VanillaSwap.Type type, DoubleVector nominal1, DoubleVector nominal2, Schedule schedule1, InterestRateIndex index1, DayCounter dayCount1, Schedule schedule2, InterestRateIndex index2, DayCounter dayCount2, bool intermediateCapitalExchange, bool finalCapitalExchange, DoubleVector gearing1, DoubleVector spread1, DoubleVector cappedRate1) : this(NQuantLibcPINVOKE.new_FloatFloatSwap__SWIG_7((int)type, DoubleVector.getCPtr(nominal1), DoubleVector.getCPtr(nominal2), Schedule.getCPtr(schedule1), InterestRateIndex.getCPtr(index1), DayCounter.getCPtr(dayCount1), Schedule.getCPtr(schedule2), InterestRateIndex.getCPtr(index2), DayCounter.getCPtr(dayCount2), intermediateCapitalExchange, finalCapitalExchange, DoubleVector.getCPtr(gearing1), DoubleVector.getCPtr(spread1), DoubleVector.getCPtr(cappedRate1)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public NonstandardSwap(VanillaSwap.Type type, DoubleVector fixedNominal, DoubleVector floatingNominal, Schedule fixedSchedule, DoubleVector fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, IborIndex index, DoubleVector gearing, DoubleVector spread, DayCounter floatDayCount) : this(NQuantLibcPINVOKE.new_NonstandardSwap__SWIG_3((int)type, DoubleVector.getCPtr(fixedNominal), DoubleVector.getCPtr(floatingNominal), Schedule.getCPtr(fixedSchedule), DoubleVector.getCPtr(fixedRate), DayCounter.getCPtr(fixedDayCount), Schedule.getCPtr(floatSchedule), IborIndex.getCPtr(index), DoubleVector.getCPtr(gearing), DoubleVector.getCPtr(spread), DayCounter.getCPtr(floatDayCount)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public FloatFloatSwap(VanillaSwap.Type type, DoubleVector nominal1, DoubleVector nominal2, Schedule schedule1, InterestRateIndex index1, DayCounter dayCount1, Schedule schedule2, InterestRateIndex index2, DayCounter dayCount2) : this(NQuantLibcPINVOKE.new_FloatFloatSwap__SWIG_12((int)type, DoubleVector.getCPtr(nominal1), DoubleVector.getCPtr(nominal2), Schedule.getCPtr(schedule1), InterestRateIndex.getCPtr(index1), DayCounter.getCPtr(dayCount1), Schedule.getCPtr(schedule2), InterestRateIndex.getCPtr(index2), DayCounter.getCPtr(dayCount2)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public VanillaSwap(VanillaSwap.Type type, double nominal, Schedule fixedSchedule, double fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, IborIndex index, double spread, DayCounter floatingDayCount) : this(NQuantLibcPINVOKE.new_VanillaSwap((int)type, nominal, Schedule.getCPtr(fixedSchedule), fixedRate, DayCounter.getCPtr(fixedDayCount), Schedule.getCPtr(floatSchedule), IborIndex.getCPtr(index), spread, DayCounter.getCPtr(floatingDayCount)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public NonstandardSwap(VanillaSwap.Type type, DoubleVector fixedNominal, DoubleVector floatingNominal, Schedule fixedSchedule, DoubleVector fixedRate, DayCounter fixedDayCount, Schedule floatSchedule, IborIndex index, DoubleVector gearing, DoubleVector spread, DayCounter floatDayCount, bool intermediateCapitalExchange, bool finalCapitalExchange, BusinessDayConvention paymentConvention) : this(NQuantLibcPINVOKE.new_NonstandardSwap__SWIG_0((int)type, DoubleVector.getCPtr(fixedNominal), DoubleVector.getCPtr(floatingNominal), Schedule.getCPtr(fixedSchedule), DoubleVector.getCPtr(fixedRate), DayCounter.getCPtr(fixedDayCount), Schedule.getCPtr(floatSchedule), IborIndex.getCPtr(index), DoubleVector.getCPtr(gearing), DoubleVector.getCPtr(spread), DayCounter.getCPtr(floatDayCount), intermediateCapitalExchange, finalCapitalExchange, (int)paymentConvention), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public VanillaSwap.Type type()
{
VanillaSwap.Type ret = (VanillaSwap.Type)NQuantLibcPINVOKE.NonstandardSwap_type(swigCPtr);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public MakeVanillaSwap withType(VanillaSwap.Type type)
{
MakeVanillaSwap ret = new MakeVanillaSwap(NQuantLibcPINVOKE.MakeVanillaSwap_withType(swigCPtr, (int)type), false);
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public FloatFloatSwap(VanillaSwap.Type type,
List <double> nominal1,
List <double> nominal2,
Schedule schedule1,
InterestRateIndex index1,
DayCounter dayCount1,
Schedule schedule2,
InterestRateIndex index2,
DayCounter dayCount2,
bool intermediateCapitalExchange = false,
bool finalCapitalExchange = false,
List <double> gearing1 = null,
List <double> spread1 = null,
List <double?> cappedRate1 = null,
List <double?> flooredRate1 = null,
List <double> gearing2 = null,
List <double> spread2 = null,
List <double?> cappedRate2 = null,
List <double?> flooredRate2 = null,
BusinessDayConvention?paymentConvention1 = null,
BusinessDayConvention?paymentConvention2 = null)
: base(2)
{
type_ = type;
nominal1_ = nominal1;
nominal2_ = nominal2;
schedule1_ = schedule1;
schedule2_ = schedule2;
index1_ = index1;
index2_ = index2;
gearing1_ = gearing1;
gearing2_ = gearing2;
spread1_ = spread1;
spread2_ = spread2;
cappedRate1_ = cappedRate1;
flooredRate1_ = flooredRate1;
cappedRate2_ = cappedRate2;
flooredRate2_ = flooredRate2;
dayCount1_ = dayCount1;
dayCount2_ = dayCount2;
intermediateCapitalExchange_ = intermediateCapitalExchange;
finalCapitalExchange_ = finalCapitalExchange;
init(paymentConvention1, paymentConvention2);
}
public FloatFloatSwap(VanillaSwap.Type type,
double nominal1,
double nominal2,
Schedule schedule1,
InterestRateIndex index1,
DayCounter dayCount1,
Schedule schedule2,
InterestRateIndex index2,
DayCounter dayCount2,
bool intermediateCapitalExchange = false,
bool finalCapitalExchange = false,
double gearing1 = 1.0,
double spread1 = 0.0,
double?cappedRate1 = null,
double?flooredRate1 = null,
double gearing2 = 1.0,
double spread2 = 0.0,
double?cappedRate2 = null,
double?flooredRate2 = null,
BusinessDayConvention?paymentConvention1 = null,
BusinessDayConvention?paymentConvention2 = null)
: base(2)
{
type_ = type;
nominal1_ = new InitializedList <double> (schedule1.size() - 1, nominal1);
nominal2_ = new InitializedList <double> (schedule2.size() - 1, nominal2);
schedule1_ = schedule1;
schedule2_ = schedule2;
index1_ = index1;
index2_ = index2;
gearing1_ = new InitializedList <double>(schedule1.size() - 1, gearing1);
gearing2_ = new InitializedList <double>(schedule2.size() - 1, gearing2);
spread1_ = new InitializedList <double>(schedule1.size() - 1, spread1);
spread2_ = new InitializedList <double>(schedule2.size() - 1, spread2);
cappedRate1_ = new InitializedList <double?>(schedule1.size() - 1, cappedRate1);
flooredRate1_ = new InitializedList <double?>(schedule1.size() - 1, flooredRate1);
cappedRate2_ = new InitializedList <double?>(schedule2.size() - 1, cappedRate2);
flooredRate2_ = new InitializedList <double?>(schedule2.size() - 1, flooredRate2);
dayCount1_ = dayCount1; dayCount2_ = dayCount2;
intermediateCapitalExchange_ = intermediateCapitalExchange;
finalCapitalExchange_ = finalCapitalExchange;
init(paymentConvention1, paymentConvention2);
}
public CommonVars()
{
type = VanillaSwap.Type.Payer;
settlementDays = 2;
nominal = 100.0;
fixedConvention = BusinessDayConvention.Unadjusted;
floatingConvention = BusinessDayConvention.ModifiedFollowing;
fixedFrequency = Frequency.Annual;
floatingFrequency = Frequency.Semiannual;
fixedDayCount = new Thirty360();
index = new Euribor(new Period(floatingFrequency), termStructure);
calendar = index.fixingCalendar();
today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
settlement = calendar.advance(today, settlementDays, TimeUnit.Days);
termStructure.linkTo(Utilities.flatRate(settlement, 0.05, new Actual365Fixed()));
}
public MakeVanillaSwap(Period swapTenor, IborIndex index, double?fixedRate = null, Period forwardStart = null)
{
swapTenor_ = swapTenor;
iborIndex_ = index;
fixedRate_ = fixedRate;
forwardStart_ = forwardStart ?? new Period(0, TimeUnit.Days);
settlementDays_ = iborIndex_.fixingDays();
fixedCalendar_ = floatCalendar_ = index.fixingCalendar();
type_ = VanillaSwap.Type.Payer;
nominal_ = 1.0;
floatTenor_ = index.tenor();
fixedConvention_ = fixedTerminationDateConvention_ = BusinessDayConvention.ModifiedFollowing;
floatConvention_ = floatTerminationDateConvention_ = index.businessDayConvention();
fixedRule_ = floatRule_ = DateGeneration.Rule.Backward;
fixedEndOfMonth_ = floatEndOfMonth_ = false;
fixedFirstDate_ = fixedNextToLastDate_ = floatFirstDate_ = floatNextToLastDate_ = null;
floatSpread_ = 0.0;
floatDayCount_ = index.dayCounter();
}
// setup
public CommonVars()
{
startYears = 1;
length = 5;
type = VanillaSwap.Type.Payer;
nominal = 1000.0;
settlementDays = 2;
fixedConvention = BusinessDayConvention.Unadjusted;
floatingConvention = BusinessDayConvention.ModifiedFollowing;
fixedFrequency = Frequency.Annual;
floatingFrequency = Frequency.Semiannual;
fixedDayCount = new Thirty360();
termStructure = new RelinkableHandle <YieldTermStructure>();
termStructure.linkTo(Utilities.flatRate(new Date(19, Month.February, 2002), 0.04875825, new Actual365Fixed()));
index = new Euribor6M(termStructure);
calendar = index.fixingCalendar();
today = calendar.adjust(Date.Today);
settlement = calendar.advance(today, settlementDays, TimeUnit.Days);
}
public MakeVanillaSwap(Period swapTenor, IborIndex index, double? fixedRate, Period forwardStart) {
swapTenor_ = swapTenor;
iborIndex_ = index;
fixedRate_ = fixedRate;
forwardStart_ = forwardStart;
effectiveDate_ = null;
fixedCalendar_ = floatCalendar_ = index.fixingCalendar();
type_ = VanillaSwap.Type.Payer;
nominal_ = 1.0;
fixedTenor_ = new Period(1, TimeUnit.Years);
floatTenor_ = index.tenor();
fixedConvention_ = fixedTerminationDateConvention_ = BusinessDayConvention.ModifiedFollowing;
floatConvention_ = floatTerminationDateConvention_ = index.businessDayConvention();
fixedRule_ = floatRule_ = DateGeneration.Rule.Backward;
fixedEndOfMonth_ = floatEndOfMonth_ = false;
fixedFirstDate_ = fixedNextToLastDate_ = floatFirstDate_ = floatNextToLastDate_ = null;
floatSpread_ = 0.0;
fixedDayCount_ = new Thirty360(Thirty360.Thirty360Convention.BondBasis);
floatDayCount_ = index.dayCounter();
engine_ = new DiscountingSwapEngine(index.forwardingTermStructure());
}
public MakeVanillaSwap(Period swapTenor, IborIndex index, double?fixedRate, Period forwardStart)
{
swapTenor_ = swapTenor;
iborIndex_ = index;
fixedRate_ = fixedRate;
forwardStart_ = forwardStart;
effectiveDate_ = null;
fixedCalendar_ = floatCalendar_ = index.fixingCalendar();
type_ = VanillaSwap.Type.Payer;
nominal_ = 1.0;
fixedTenor_ = new Period(1, TimeUnit.Years);
floatTenor_ = index.tenor();
fixedConvention_ = fixedTerminationDateConvention_ = BusinessDayConvention.ModifiedFollowing;
floatConvention_ = floatTerminationDateConvention_ = index.businessDayConvention();
fixedRule_ = floatRule_ = DateGeneration.Rule.Backward;
fixedEndOfMonth_ = floatEndOfMonth_ = false;
fixedFirstDate_ = fixedNextToLastDate_ = floatFirstDate_ = floatNextToLastDate_ = null;
floatSpread_ = 0.0;
fixedDayCount_ = new Thirty360(Thirty360.Thirty360Convention.BondBasis);
floatDayCount_ = index.dayCounter();
engine_ = new DiscountingSwapEngine(index.forwardingTermStructure());
}
public MakeVanillaSwap receiveFixed(bool flag = true)
{
type_ = flag ? VanillaSwap.Type.Receiver : VanillaSwap.Type.Payer;
return(this);
}
public MakeSwaption withUnderlyingType(VanillaSwap.Type type)
{
underlyingType_ = type;
return(this);
}
// setup
public CommonVars()
{
startYears = 1;
length = 5;
type = VanillaSwap.Type.Payer;
nominal = 1000.0;
settlementDays = 2;
fixedConvention = BusinessDayConvention.Unadjusted;
floatingConvention = BusinessDayConvention.ModifiedFollowing;
fixedFrequency = Frequency.Annual;
floatingFrequency = Frequency.Semiannual;
fixedDayCount = new Thirty360();
termStructure = new RelinkableHandle<YieldTermStructure>();
termStructure.linkTo(Utilities.flatRate(new Date(19, Month.February, 2002), 0.04875825, new Actual365Fixed()));
index = new Euribor6M(termStructure);
calendar = index.fixingCalendar();
today = calendar.adjust(Date.Today);
settlement = calendar.advance(today, settlementDays, TimeUnit.Days);
}
protected override void performCalculations()
{
Calendar calendar = index_.fixingCalendar();
int fixingDays = index_.fixingDays();
Date exerciseDate = exerciseDate_;
if (exerciseDate == null)
{
exerciseDate = calendar.advance(termStructure_.link.referenceDate(),
maturity_,
index_.businessDayConvention());
}
Date startDate = calendar.advance(exerciseDate,
fixingDays, TimeUnit.Days,
index_.businessDayConvention());
Date endDate = endDate_;
if (endDate == null)
{
endDate = calendar.advance(startDate, length_,
index_.businessDayConvention());
}
Schedule fixedSchedule = new Schedule(startDate, endDate, fixedLegTenor_, calendar,
index_.businessDayConvention(),
index_.businessDayConvention(),
DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(startDate, endDate, index_.tenor(), calendar,
index_.businessDayConvention(),
index_.businessDayConvention(),
DateGeneration.Rule.Forward, false);
IPricingEngine swapEngine = new DiscountingSwapEngine(termStructure_, false);
VanillaSwap.Type type = VanillaSwap.Type.Receiver;
VanillaSwap temp = new VanillaSwap(VanillaSwap.Type.Receiver, nominal_,
fixedSchedule, 0.0, fixedLegDayCounter_,
floatSchedule, index_, 0.0, floatingLegDayCounter_);
temp.setPricingEngine(swapEngine);
double forward = temp.fairRate();
if (!strike_.HasValue)
{
exerciseRate_ = forward;
}
else
{
exerciseRate_ = strike_.Value;
type = strike_ <= forward ? VanillaSwap.Type.Receiver : VanillaSwap.Type.Payer;
// ensure that calibration instrument is out of the money
}
swap_ = new VanillaSwap(type, nominal_,
fixedSchedule, exerciseRate_, fixedLegDayCounter_,
floatSchedule, index_, 0.0, floatingLegDayCounter_);
swap_.setPricingEngine(swapEngine);
Exercise exercise = new EuropeanExercise(exerciseDate);
swaption_ = new Swaption(swap_, exercise);
base.performCalculations();
}
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)
{
try
{
DateTime timer = DateTime.Now;
Calendar calendar = new TARGET();
Date todaysDate = new Date(10, Month.March, 2004);
// must be a business day
todaysDate = calendar.adjust(todaysDate);
Settings.setEvaluationDate(todaysDate);
IborIndex yieldIndx = new Euribor3M();
int[] tenorsSwapMkt = { 5, 10, 15, 20, 25, 30 };
// rates ignoring counterparty risk:
double[] ratesSwapmkt = { .03249, .04074, .04463, .04675, .04775, .04811 };
List <RateHelper> swapHelpers = new List <RateHelper>();
for (int i = 0; i < tenorsSwapMkt.Length; i++)
{
swapHelpers.Add(new SwapRateHelper(new Handle <Quote>(new SimpleQuote(ratesSwapmkt[i])),
new Period(tenorsSwapMkt[i], TimeUnit.Years),
new TARGET(),
Frequency.Quarterly,
BusinessDayConvention.ModifiedFollowing,
new ActualActual(ActualActual.Convention.ISDA),
yieldIndx));
}
YieldTermStructure swapTS = new PiecewiseYieldCurve <Discount, LogLinear>(2, new TARGET(), swapHelpers,
new ActualActual(ActualActual.Convention.ISDA));
swapTS.enableExtrapolation();
IPricingEngine riskFreeEngine = new DiscountingSwapEngine(new Handle <YieldTermStructure>(swapTS));
List <Handle <DefaultProbabilityTermStructure> > defaultIntensityTS =
new List <Handle <DefaultProbabilityTermStructure> >();
int[] defaultTenors = { 0, 12, 36, 60, 84, 120, 180, 240, 300, 360 }; // months
// Three risk levels:
double[] intensitiesLow = { 0.0036, 0.0036, 0.0065, 0.0099, 0.0111, 0.0177, 0.0177, 0.0177, 0.0177, 0.0177, 0.0177 };
double[] intensitiesMedium = { 0.0202, 0.0202, 0.0231, 0.0266, 0.0278, 0.0349, 0.0349, 0.0349, 0.0349, 0.0349, 0.0349 };
double[] intensitiesHigh = { 0.0534, 0.0534, 0.0564, 0.06, 0.0614, 0.0696, 0.0696, 0.0696, 0.0696, 0.0696, 0.0696 };
// Recovery rates:
double ctptyRRLow = 0.4, ctptyRRMedium = 0.35, ctptyRRHigh = 0.3;
List <Date> defaultTSDates = new List <Date>();
List <double> intesitiesVLow = new List <double>(),
intesitiesVMedium = new List <double>(),
intesitiesVHigh = new List <double>();
for (int i = 0; i < defaultTenors.Length; i++)
{
defaultTSDates.Add(new TARGET().advance(todaysDate, new Period(defaultTenors[i], TimeUnit.Months)));
intesitiesVLow.Add(intensitiesLow[i]);
intesitiesVMedium.Add(intensitiesMedium[i]);
intesitiesVHigh.Add(intensitiesHigh[i]);
}
defaultIntensityTS.Add(new Handle <DefaultProbabilityTermStructure>(
new InterpolatedHazardRateCurve <BackwardFlat>(
defaultTSDates,
intesitiesVLow,
new Actual360(),
new TARGET())));
defaultIntensityTS.Add(new Handle <DefaultProbabilityTermStructure>(
new InterpolatedHazardRateCurve <BackwardFlat>(
defaultTSDates,
intesitiesVMedium,
new Actual360(),
new TARGET())));
defaultIntensityTS.Add(new Handle <DefaultProbabilityTermStructure>(
new InterpolatedHazardRateCurve <BackwardFlat>(
defaultTSDates,
intesitiesVHigh,
new Actual360(),
new TARGET())));
double blackVol = 0.15;
IPricingEngine ctptySwapCvaLow = new CounterpartyAdjSwapEngine(new Handle <YieldTermStructure>(swapTS),
blackVol, defaultIntensityTS[0], ctptyRRLow);
IPricingEngine ctptySwapCvaMedium = new CounterpartyAdjSwapEngine(new Handle <YieldTermStructure>(swapTS),
blackVol, defaultIntensityTS[1], ctptyRRMedium);
IPricingEngine ctptySwapCvaHigh = new CounterpartyAdjSwapEngine(new Handle <YieldTermStructure>(swapTS),
blackVol, defaultIntensityTS[2], ctptyRRHigh);
defaultIntensityTS[0].link.enableExtrapolation();
defaultIntensityTS[1].link.enableExtrapolation();
defaultIntensityTS[2].link.enableExtrapolation();
// SWAP RISKY REPRICE----------------------------------------------
// fixed leg
Frequency fixedLegFrequency = Frequency.Quarterly;
BusinessDayConvention fixedLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new ActualActual(ActualActual.Convention.ISDA);
DayCounter floatingLegDayCounter = new ActualActual(ActualActual.Convention.ISDA);
VanillaSwap.Type swapType =
//VanillaSwap::Receiver ;
VanillaSwap.Type.Payer;
IborIndex yieldIndxS = new Euribor3M(new Handle <YieldTermStructure>(swapTS));
List <VanillaSwap> riskySwaps = new List <VanillaSwap>();
for (int i = 0; i < tenorsSwapMkt.Length; i++)
{
riskySwaps.Add(new MakeVanillaSwap(new Period(tenorsSwapMkt[i], TimeUnit.Years),
yieldIndxS,
ratesSwapmkt[i],
new Period(0, TimeUnit.Days))
.withSettlementDays(2)
.withFixedLegDayCount(fixedLegDayCounter)
.withFixedLegTenor(new Period(fixedLegFrequency))
.withFixedLegConvention(fixedLegConvention)
.withFixedLegTerminationDateConvention(fixedLegConvention)
.withFixedLegCalendar(calendar)
.withFloatingLegCalendar(calendar)
.withNominal(100.0)
.withType(swapType).value());
}
Console.WriteLine("-- Correction in the contract fix rate in bp --");
/* The paper plots correction to be substracted, here is printed
* with its sign
*/
for (int i = 0; i < riskySwaps.Count; i++)
{
riskySwaps[i].setPricingEngine(riskFreeEngine);
// should recover the input here:
double nonRiskyFair = riskySwaps[i].fairRate();
Console.Write((tenorsSwapMkt[i]).ToString("0").PadLeft(6));
Console.Write(" | " + nonRiskyFair.ToString("P3").PadLeft(6));
// Low Risk:
riskySwaps[i].setPricingEngine(ctptySwapCvaLow);
Console.Write(" | " + (10000.0 * (riskySwaps[i].fairRate() - nonRiskyFair)).ToString("#0.00").PadLeft(6));
//cout << " | " << setw(6) << riskySwaps[i].NPV() ;
// Medium Risk:
riskySwaps[i].setPricingEngine(ctptySwapCvaMedium);
Console.Write(" | " + (10000.0 * (riskySwaps[i].fairRate() - nonRiskyFair)).ToString("#0.00").PadLeft(6));
//cout << " | " << setw(6) << riskySwaps[i].NPV() ;
riskySwaps[i].setPricingEngine(ctptySwapCvaHigh);
Console.Write(" | " + (10000.0 * (riskySwaps[i].fairRate() - nonRiskyFair)).ToString("#0.00").PadLeft(6));
//cout << " | " << setw(6) << riskySwaps[i].NPV() ;
Console.WriteLine();
}
Console.WriteLine();
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
catch (Exception e)
{
Console.Write(e.Message);
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
}
public MakeVanillaSwap withType(VanillaSwap.Type type)
{
type_ = type;
return this;
}
public MakeVanillaSwap receiveFixed(bool flag)
{
type_ = flag ? VanillaSwap.Type.Receiver : VanillaSwap.Type.Payer;
return this;
}
public override void calculate()
{
/* both DTS, YTS ref dates and pricing date consistency
* checks? settlement... */
Utils.QL_REQUIRE(!discountCurve_.empty(), () => "no discount term structure set");
Utils.QL_REQUIRE(!defaultTS_.empty(), () => "no ctpty default term structure set");
Utils.QL_REQUIRE(!swaptionletEngine_.empty(), () => "no swap option engine set");
Date priceDate = defaultTS_.link.referenceDate();
double cumOptVal = 0.0, cumPutVal = 0.0;
// Vanilla swap so 0 leg is floater
int index = 0;
Date nextFD = arguments_.fixedPayDates[index];
Date swapletStart = priceDate;
while (nextFD < priceDate)
{
index++;
nextFD = arguments_.fixedPayDates[index];
}
// Compute fair spread for strike value:
// copy args into the non risky engine
Swap.Arguments noCVAArgs = baseSwapEngine_.link.getArguments() as Swap.Arguments;
noCVAArgs.legs = this.arguments_.legs;
noCVAArgs.payer = this.arguments_.payer;
baseSwapEngine_.link.calculate();
double baseSwapRate = ((FixedRateCoupon)arguments_.legs[0][0]).rate();
Swap.Results vSResults = baseSwapEngine_.link.getResults() as Swap.Results;
double?baseSwapFairRate = -baseSwapRate * vSResults.legNPV[1] / vSResults.legNPV[0];
double?baseSwapNPV = vSResults.value;
VanillaSwap.Type reversedType = arguments_.type == VanillaSwap.Type.Payer
? VanillaSwap.Type.Receiver
: VanillaSwap.Type.Payer;
// Swaplet options summatory:
while (nextFD != arguments_.fixedPayDates.Last())
{
// iFD coupon not fixed, create swaptionlet:
IborIndex swapIndex = ((FloatingRateCoupon)arguments_.legs[1][0]).index() as IborIndex;
// Alternatively one could cap this period to, say, 1M
Period baseSwapsTenor = new Period(arguments_.fixedPayDates.Last().serialNumber()
- swapletStart.serialNumber(), TimeUnit.Days);
VanillaSwap swaplet = new MakeVanillaSwap(baseSwapsTenor, swapIndex, baseSwapFairRate)
.withType(arguments_.type)
.withNominal(arguments_.nominal)
.withEffectiveDate(swapletStart)
.withTerminationDate(arguments_.fixedPayDates.Last()).value();
VanillaSwap revSwaplet = new MakeVanillaSwap(baseSwapsTenor, swapIndex, baseSwapFairRate)
.withType(reversedType)
.withNominal(arguments_.nominal)
.withEffectiveDate(swapletStart)
.withTerminationDate(arguments_.fixedPayDates.Last()).value();
Swaption swaptionlet = new Swaption(swaplet, new EuropeanExercise(swapletStart));
Swaption putSwaplet = new Swaption(revSwaplet, new EuropeanExercise(swapletStart));
swaptionlet.setPricingEngine(swaptionletEngine_.currentLink());
putSwaplet.setPricingEngine(swaptionletEngine_.currentLink());
// atm underlying swap means that the value of put = value
// call so this double pricing is not needed
cumOptVal += swaptionlet.NPV() * defaultTS_.link.defaultProbability(
swapletStart, nextFD);
cumPutVal += putSwaplet.NPV() * invstDTS_.link.defaultProbability(swapletStart, nextFD);
swapletStart = nextFD;
index++;
nextFD = arguments_.fixedPayDates[index];
}
results_.value = baseSwapNPV - (1.0 - ctptyRecoveryRate_) * cumOptVal + (1.0 - invstRecoveryRate_) * cumPutVal;
results_.fairRate = -baseSwapRate * (vSResults.legNPV[1] - (1.0 - ctptyRecoveryRate_) * cumOptVal +
(1.0 - invstRecoveryRate_) * cumPutVal) / vSResults.legNPV[0];
}
public MakeVanillaSwap withType(VanillaSwap.Type type)
{
type_ = type;
return(this);
}
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(string[] args)
{
DateTime timer = DateTime.Now;
Date todaysDate = new Date(15, 2, 2002);
Calendar calendar = new TARGET();
Date settlementDate = new Date(19, 2, 2002);
Settings.setEvaluationDate(todaysDate);
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
Handle <YieldTermStructure> rhTermStructure = new Handle <YieldTermStructure>(
new FlatForward(settlementDate, new Handle <Quote>(flatRate),
new Actual365Fixed()));
// Define the ATM/OTM/ITM swaps
Frequency fixedLegFrequency = Frequency.Annual;
BusinessDayConvention fixedLegConvention = BusinessDayConvention.Unadjusted;
BusinessDayConvention floatingLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new Thirty360(Thirty360.Thirty360Convention.European);
Frequency floatingLegFrequency = Frequency.Semiannual;
VanillaSwap.Type type = VanillaSwap.Type.Payer;
double dummyFixedRate = 0.03;
IborIndex indexSixMonths = new Euribor6M(rhTermStructure);
Date startDate = calendar.advance(settlementDate, 1, TimeUnit.Years,
floatingLegConvention);
Date maturity = calendar.advance(startDate, 5, TimeUnit.Years,
floatingLegConvention);
Schedule fixedSchedule = new Schedule(startDate, maturity, new Period(fixedLegFrequency),
calendar, fixedLegConvention, fixedLegConvention,
DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(startDate, maturity, new Period(floatingLegFrequency),
calendar, floatingLegConvention, floatingLegConvention,
DateGeneration.Rule.Forward, false);
VanillaSwap swap = new VanillaSwap(
type, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
swap.setPricingEngine(new DiscountingSwapEngine(rhTermStructure));
double fixedAtmRate = swap.fairRate();
double fixedOtmRate = fixedAtmRate * 1.2;
double fixedItmRate = fixedAtmRate * 0.8;
VanillaSwap atmSwap = new VanillaSwap(
type, 1000.0,
fixedSchedule, fixedAtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap otmSwap = new VanillaSwap(
type, 1000.0,
fixedSchedule, fixedOtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap itmSwap = new VanillaSwap(
type, 1000.0,
fixedSchedule, fixedItmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
// defining the swaptions to be used in model calibration
List <Period> swaptionMaturities = new List <Period>(5);
swaptionMaturities.Add(new Period(1, TimeUnit.Years));
swaptionMaturities.Add(new Period(2, TimeUnit.Years));
swaptionMaturities.Add(new Period(3, TimeUnit.Years));
swaptionMaturities.Add(new Period(4, TimeUnit.Years));
swaptionMaturities.Add(new Period(5, TimeUnit.Years));
List <CalibrationHelper> swaptions = new List <CalibrationHelper>();
// List of times that have to be included in the timegrid
List <double> times = new List <double>();
for (int i = 0; i < NumRows; i++)
{
int j = NumCols - i - 1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i * NumCols + j;
Quote vol = new SimpleQuote(SwaptionVols[k]);
swaptions.Add(new SwaptionHelper(swaptionMaturities[i],
new Period(SwapLenghts[j], TimeUnit.Years),
new Handle <Quote>(vol),
indexSixMonths,
indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure, false));
swaptions.Last().addTimesTo(times);
}
// Building time-grid
TimeGrid grid = new TimeGrid(times, 30);
// defining the models
G2 modelG2 = new G2(rhTermStructure);
HullWhite modelHw = new HullWhite(rhTermStructure);
HullWhite modelHw2 = new HullWhite(rhTermStructure);
BlackKarasinski modelBk = new BlackKarasinski(rhTermStructure);
// model calibrations
Console.WriteLine("G2 (analytic formulae) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
swaptions[i].setPricingEngine(new G2SwaptionEngine(modelG2, 6.0, 16));
}
CalibrateModel(modelG2, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.0000000}\n" +
"b = {2:0.000000}, " +
"eta = {3:0.0000000}\n" +
"rho = {4:0.00000}\n",
modelG2.parameters()[0],
modelG2.parameters()[1],
modelG2.parameters()[2],
modelG2.parameters()[3],
modelG2.parameters()[4]);
Console.WriteLine("Hull-White (analytic formulae) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
swaptions[i].setPricingEngine(new JamshidianSwaptionEngine(modelHw));
}
CalibrateModel(modelHw, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.0000000}\n",
modelHw.parameters()[0],
modelHw.parameters()[1]);
Console.WriteLine("Hull-White (numerical) calibration");
for (int i = 0; i < swaptions.Count(); i++)
{
swaptions[i].setPricingEngine(new TreeSwaptionEngine(modelHw2, grid));
}
CalibrateModel(modelHw2, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.0000000}\n",
modelHw2.parameters()[0],
modelHw2.parameters()[1]);
Console.WriteLine("Black-Karasinski (numerical) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
swaptions[i].setPricingEngine(new TreeSwaptionEngine(modelBk, grid));
}
CalibrateModel(modelBk, swaptions);
Console.WriteLine("calibrated to:\n" +
"a = {0:0.000000}, " +
"sigma = {1:0.00000}\n",
modelBk.parameters()[0],
modelBk.parameters()[1]);
// ATM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption "
+ "struck at {0:0.00000 %} (ATM)",
fixedAtmRate);
List <Date> bermudanDates = new List <Date>();
List <CashFlow> leg = swap.fixedLeg();
for (int i = 0; i < leg.Count; i++)
{
Coupon coupon = (Coupon)leg[i];
bermudanDates.Add(coupon.accrualStartDate());
}
Exercise bermudanExercise = new BermudanExercise(bermudanDates);
Swaption bermudanSwaption = new Swaption(atmSwap, bermudanExercise);
// Do the pricing for each model
// G2 price the European swaption here, it should switch to bermudan
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelG2, 50));
Console.WriteLine("G2: {0:0.00}", bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: {0:0.000}", bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): {0:0.000}", bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK: {0:0.000}", bermudanSwaption.NPV());
// OTM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption "
+ "struck at {0:0.00000 %} (OTM)",
fixedOtmRate);
Swaption otmBermudanSwaption = new Swaption(otmSwap, bermudanExercise);
// Do the pricing for each model
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelG2, 50));
Console.WriteLine("G2: {0:0.0000}", otmBermudanSwaption.NPV());
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: {0:0.0000}", otmBermudanSwaption.NPV());
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): {0:0.000}", otmBermudanSwaption.NPV());
otmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK: {0:0.0000}", otmBermudanSwaption.NPV());
// ITM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption "
+ "struck at {0:0.00000 %} (ITM)",
fixedItmRate);
Swaption itmBermudanSwaption = new Swaption(itmSwap, bermudanExercise);
// Do the pricing for each model
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelG2, 50));
Console.WriteLine("G2: {0:0.000}", itmBermudanSwaption.NPV());
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: {0:0.000}", itmBermudanSwaption.NPV());
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): {0:0.000}", itmBermudanSwaption.NPV());
itmBermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK: {0:0.000}", itmBermudanSwaption.NPV());
Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
Console.WriteLine();
Console.Write("Press any key to continue ...");
Console.ReadKey();
}
public CommonVars()
{
type = VanillaSwap.Type.Payer;
settlementDays = 2;
nominal = 100.0;
fixedConvention = BusinessDayConvention.Unadjusted;
floatingConvention = BusinessDayConvention.ModifiedFollowing;
fixedFrequency = Frequency.Annual;
floatingFrequency = Frequency.Semiannual;
fixedDayCount = new Thirty360();
index = new Euribor(new Period(floatingFrequency), termStructure);
calendar = index.fixingCalendar();
today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
settlement = calendar.advance(today, settlementDays, TimeUnit.Days);
termStructure.linkTo(Utilities.flatRate(settlement, 0.05, new Actual365Fixed()));
}