public CreditDefaultSwap value()
{
Date evaluation = Settings.evaluationDate();
Date start = evaluation + 1;
Date upfrontDate = new WeekendsOnly().advance(evaluation, new Period(3, TimeUnit.Days));
Date end;
if (tenor_ != null)
{
end = start + tenor_;
}
else
{
end = termDate_;
}
Schedule schedule = new Schedule(start, end, couponTenor_, new WeekendsOnly(),
BusinessDayConvention.Following, BusinessDayConvention.Unadjusted, DateGeneration.Rule.CDS,
false, null, null);
CreditDefaultSwap cds = new CreditDefaultSwap(side_, nominal_, upfrontRate_, couponRate_, schedule,
BusinessDayConvention.Following, dayCounter_, true, true, start, upfrontDate, null, lastPeriodDayCounter_);
cds.setPricingEngine(engine_);
return(cds);
}
public CdsOption(CreditDefaultSwap swap, Exercise exercise) : this(NQuantLibcPINVOKE.new_CdsOption__SWIG_1(CreditDefaultSwap.getCPtr(swap), Exercise.getCPtr(exercise)), true)
{
if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
{
throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
}
public void DemonstrateCreationOfCreditDefaultSwap()
{
// CREATE the cds flow conventions for credit default swap
var cdsFlowConventions = new CdsFlowConventions(
scope: null,
code: null,
currency: "GBP",
paymentFrequency: "6M",
rollConvention: "MF",
dayCountConvention: "Act365",
paymentCalendars: new List <string>(),
resetCalendars: new List <string>(),
rollFrequency: "6M",
settleDays: 2,
resetDays: 2
);
var cdsProtectionDetailSpecification = new CdsProtectionDetailSpecification(
seniority: CdsProtectionDetailSpecification.SeniorityEnum.SNR,
restructuringType: CdsProtectionDetailSpecification.RestructuringTypeEnum.CR,
protectStartDay: true,
payAccruedInterestOnDefault: false);
var cds = new CreditDefaultSwap(
ticker: "ACME",
startDate: new DateTimeOffset(2020, 2, 7, 0, 0, 0, TimeSpan.Zero),
maturityDate: new DateTimeOffset(2020, 9, 18, 0, 0, 0, TimeSpan.Zero),
flowConventions: cdsFlowConventions,
couponRate: 0.5m,
protectionDetailSpecification: cdsProtectionDetailSpecification,
instrumentType: LusidInstrument.InstrumentTypeEnum.CreditDefaultSwap
);
// ASSERT that it was created
Assert.That(cds, Is.Not.Null);
// CAN NOW UPSERT TO LUSID
string uniqueId = "id-cds-1";
UpsertOtcToLusid(cds, "some-name-for-this-cds", uniqueId);
// CAN NOW QUERY FROM LUSID
var retrieved = QueryOtcFromLusid(uniqueId);
Assert.That(retrieved.InstrumentType == LusidInstrument.InstrumentTypeEnum.CreditDefaultSwap);
var roundTripCds = retrieved as CreditDefaultSwap;
Assert.That(roundTripCds, Is.Not.Null);
Assert.That(roundTripCds.CouponRate, Is.EqualTo(cds.CouponRate));
Assert.That(roundTripCds.Ticker, Is.EqualTo(cds.Ticker));
Assert.That(roundTripCds.MaturityDate, Is.EqualTo(cds.MaturityDate));
Assert.That(roundTripCds.StartDate, Is.EqualTo(cds.StartDate));
Assert.That(roundTripCds.FlowConventions.Currency, Is.EqualTo(cds.FlowConventions.Currency));
Assert.That(roundTripCds.FlowConventions.PaymentFrequency, Is.EqualTo(cds.FlowConventions.PaymentFrequency));
Assert.That(roundTripCds.FlowConventions.ResetDays, Is.EqualTo(cds.FlowConventions.ResetDays));
Assert.That(roundTripCds.FlowConventions.SettleDays, Is.EqualTo(cds.FlowConventions.SettleDays));
Assert.That(roundTripCds.FlowConventions.PaymentCalendars.Count, Is.EqualTo(cds.FlowConventions.PaymentCalendars.Count));
Assert.That(roundTripCds.FlowConventions.PaymentCalendars, Is.EquivalentTo(cds.FlowConventions.PaymentCalendars));
}
//double fixedRate = 0.001;
//double notional = 10000.0;
//double recoveryRate = 0.4;
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> Calculates the cds. </summary>
///
/// <param name="msg"> [in,out] The message. </param>
/// <param name="fixedRate"> The fixed rate. </param>
/// <param name="notional"> The notional. </param>
/// <param name="recoveryRate"> The recovery rate. </param>
///
/// <returns> True if it succeeds, false if it fails. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////
public bool CalcCDS(ref CreditDefaultSwapRequestMessage msg, double fixedRate, double notional, double recoveryRate)
{
// Testing fair-spread calculation for credit-default swaps...
using (SavedSettings backup = new SavedSettings())
{
// Initialize curves
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
Handle <Quote> hazardRate = new Handle <Quote>(new SimpleQuote(0.01234));
RelinkableHandle <DefaultProbabilityTermStructure> probabilityCurve =
new RelinkableHandle <DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));
RelinkableHandle <YieldTermStructure> discountCurve =
new RelinkableHandle <YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today, 0.06, new Actual360()));
// Build the schedule
Date issueDate = calendar.advance(today, -1, TimeUnit.Years);
Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
BusinessDayConvention convention = BusinessDayConvention.Following;
Schedule schedule = new MakeSchedule().from(issueDate)
.to(maturity)
.withFrequency(Frequency.Quarterly)
.withCalendar(calendar)
.withTerminationDateConvention(convention)
.withRule(DateGeneration.Rule.TwentiethIMM).value();
// Build the CDS
DayCounter dayCount = new Actual360();
IPricingEngine engine = new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve);
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, dayCount, true, true);
cds.setPricingEngine(engine);
double fairRate = cds.fairSpread();
CreditDefaultSwap fairCds = new CreditDefaultSwap(Protection.Side.Seller, notional, fairRate,
schedule, convention, dayCount, true, true);
fairCds.setPricingEngine(engine);
double fairNPV = fairCds.NPV();
double tolerance = 1e-10;
msg.fairRate = fairRate;
msg.fairNPV = fairNPV;
return(Math.Abs(fairNPV) <= tolerance);
}
}
public void testImpliedHazardRate()
{
// Testing implied hazard-rate for credit-default swaps...
using (SavedSettings backup = new SavedSettings())
{
// Initialize curves
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
double h1 = 0.30, h2 = 0.40;
DayCounter dayCounter = new Actual365Fixed();
List <Date> dates = new List <Date>(3);
List <double> hazardRates = new List <double>(3);
dates.Add(today);
hazardRates.Add(h1);
dates.Add(today + new Period(5, TimeUnit.Years));
hazardRates.Add(h1);
dates.Add(today + new Period(10, TimeUnit.Years));
hazardRates.Add(h2);
RelinkableHandle <DefaultProbabilityTermStructure> probabilityCurve =
new RelinkableHandle <DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new InterpolatedHazardRateCurve <BackwardFlat>(dates,
hazardRates,
dayCounter));
RelinkableHandle <YieldTermStructure> discountCurve = new RelinkableHandle <YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today, 0.03, new Actual360()));
Frequency frequency = Frequency.Semiannual;
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
Date issueDate = calendar.advance(today, -6, TimeUnit.Months);
double fixedRate = 0.0120;
DayCounter cdsDayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
double?latestRate = null;
for (int n = 6; n <= 10; ++n)
{
Date maturity = calendar.advance(issueDate, n, TimeUnit.Years);
Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
convention, convention,
DateGeneration.Rule.Forward, false);
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, cdsDayCount, true, true);
cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve));
double NPV = cds.NPV();
double flatRate = cds.impliedHazardRate(NPV, discountCurve,
dayCounter,
recoveryRate);
if (flatRate < h1 || flatRate > h2)
{
Assert.Fail("implied hazard rate outside expected range\n"
+ " maturity: " + n + " years\n"
+ " expected minimum: " + h1 + "\n"
+ " expected maximum: " + h2 + "\n"
+ " implied rate: " + flatRate);
}
if (n > 6 && flatRate < latestRate)
{
Assert.Fail("implied hazard rate decreasing with swap maturity\n"
+ " maturity: " + n + " years\n"
+ " previous rate: " + latestRate + "\n"
+ " implied rate: " + flatRate);
}
latestRate = flatRate;
RelinkableHandle <DefaultProbabilityTermStructure> probability = new RelinkableHandle <DefaultProbabilityTermStructure>();
probability.linkTo(new FlatHazardRate(today, new Handle <Quote>(new SimpleQuote(flatRate)), dayCounter));
CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, cdsDayCount, true, true);
cds2.setPricingEngine(new MidPointCdsEngine(probability, recoveryRate, discountCurve));
double NPV2 = cds2.NPV();
double tolerance = 1.0;
if (Math.Abs(NPV - NPV2) > tolerance)
{
Assert.Fail("failed to reproduce NPV with implied rate\n"
+ " expected: " + NPV + "\n"
+ " calculated: " + NPV2);
}
}
}
}
public void testCachedMarketValue()
{
// Testing credit-default swap against cached market values...
using (SavedSettings backup = new SavedSettings())
{
Settings.setEvaluationDate(new Date(9, Month.June, 2006));
Date evalDate = Settings.evaluationDate();
Calendar calendar = new UnitedStates();
List <Date> discountDates = new List <Date>();
discountDates.Add(evalDate);
discountDates.Add(calendar.advance(evalDate, 1, TimeUnit.Weeks, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 1, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 2, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 3, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 6, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 12, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 2, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 3, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 4, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 5, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 6, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 7, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 8, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 9, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 10, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 15, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
List <double> dfs = new List <double>();
dfs.Add(1.0);
dfs.Add(0.9990151375768731);
dfs.Add(0.99570502636871183);
dfs.Add(0.99118260474528685);
dfs.Add(0.98661167950906203);
dfs.Add(0.9732592953359388);
dfs.Add(0.94724424481038083);
dfs.Add(0.89844996737120875);
dfs.Add(0.85216647839921411);
dfs.Add(0.80775477692556874);
dfs.Add(0.76517289234200347);
dfs.Add(0.72401019553182933);
dfs.Add(0.68503909569219212);
dfs.Add(0.64797499814013748);
dfs.Add(0.61263171936255534);
dfs.Add(0.5791942350748791);
dfs.Add(0.43518868769953606);
DayCounter curveDayCounter = new Actual360();
RelinkableHandle <YieldTermStructure> discountCurve = new RelinkableHandle <YieldTermStructure>();
discountCurve.linkTo(new InterpolatedDiscountCurve <LogLinear>(discountDates, dfs, curveDayCounter, null, null, null, new LogLinear()));
DayCounter dayCounter = new Thirty360();
List <Date> dates = new List <Date>();
dates.Add(evalDate);
dates.Add(calendar.advance(evalDate, 6, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 1, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 2, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 3, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 4, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 5, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 7, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 10, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
List <double> defaultProbabilities = new List <double>();
defaultProbabilities.Add(0.0000);
defaultProbabilities.Add(0.0047);
defaultProbabilities.Add(0.0093);
defaultProbabilities.Add(0.0286);
defaultProbabilities.Add(0.0619);
defaultProbabilities.Add(0.0953);
defaultProbabilities.Add(0.1508);
defaultProbabilities.Add(0.2288);
defaultProbabilities.Add(0.3666);
List <double> hazardRates = new List <double>();
hazardRates.Add(0.0);
for (int i = 1; i < dates.Count; ++i)
{
double t1 = dayCounter.yearFraction(dates[0], dates[i - 1]);
double t2 = dayCounter.yearFraction(dates[0], dates[i]);
double S1 = 1.0 - defaultProbabilities[i - 1];
double S2 = 1.0 - defaultProbabilities[i];
hazardRates.Add(Math.Log(S1 / S2) / (t2 - t1));
}
RelinkableHandle <DefaultProbabilityTermStructure> piecewiseFlatHazardRate = new RelinkableHandle <DefaultProbabilityTermStructure>();
piecewiseFlatHazardRate.linkTo(new InterpolatedHazardRateCurve <BackwardFlat>(dates, hazardRates, new Thirty360()));
// Testing credit default swap
// Build the schedule
Date issueDate = new Date(20, Month.March, 2006);
Date maturity = new Date(20, Month.June, 2013);
Frequency cdsFrequency = Frequency.Semiannual;
BusinessDayConvention cdsConvention = BusinessDayConvention.ModifiedFollowing;
Schedule schedule = new Schedule(issueDate, maturity, new Period(cdsFrequency), calendar,
cdsConvention, cdsConvention,
DateGeneration.Rule.Forward, false);
// Build the CDS
double recoveryRate = 0.25;
double fixedRate = 0.0224;
DayCounter dayCount = new Actual360();
double cdsNotional = 100.0;
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, cdsNotional, fixedRate,
schedule, cdsConvention, dayCount, true, true);
cds.setPricingEngine(new MidPointCdsEngine(piecewiseFlatHazardRate, recoveryRate, discountCurve));
double calculatedNpv = cds.NPV();
double calculatedFairRate = cds.fairSpread();
double npv = -1.364048777; // from Bloomberg we have 98.15598868 - 100.00;
double fairRate = 0.0248429452; // from Bloomberg we have 0.0258378;
double tolerance = 1e-9;
if (Math.Abs(npv - calculatedNpv) > tolerance)
{
Assert.Fail(
"Failed to reproduce the npv for the given credit-default swap\n"
+ " computed NPV: " + calculatedNpv + "\n"
+ " Given NPV: " + npv);
}
if (Math.Abs(fairRate - calculatedFairRate) > tolerance)
{
Assert.Fail("Failed to reproduce the fair rate for the given credit-default swap\n"
+ " computed fair rate: " + calculatedFairRate + "\n"
+ " Given fair rate: " + fairRate);
}
}
}
public void testImpliedHazardRate()
{
// Testing implied hazard-rate for credit-default swaps...
SavedSettings backup = new SavedSettings();
// Initialize curves
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
double h1 = 0.30, h2 = 0.40;
DayCounter dayCounter = new Actual365Fixed();
List<Date> dates = new List<Date>(3);
List<double> hazardRates = new List<double>(3);
dates.Add(today);
hazardRates.Add(h1);
dates.Add(today + new Period(5,TimeUnit.Years));
hazardRates.Add(h1);
dates.Add(today + new Period(10,TimeUnit.Years));
hazardRates.Add(h2);
RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve =
new RelinkableHandle<DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new InterpolatedHazardRateCurve<BackwardFlat>(dates,
hazardRates,
dayCounter));
RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today,0.03,new Actual360()));
Frequency frequency = Frequency.Semiannual;
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
Date issueDate = calendar.advance(today, -6, TimeUnit.Months);
double fixedRate = 0.0120;
DayCounter cdsDayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
double? latestRate = null;
for (int n=6; n<=10; ++n)
{
Date maturity = calendar.advance(issueDate, n, TimeUnit.Years);
Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
convention, convention,
DateGeneration.Rule.Forward, false);
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, cdsDayCount,true, true);
cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve));
double NPV = cds.NPV();
double flatRate = cds.impliedHazardRate(NPV, discountCurve,
dayCounter,
recoveryRate);
if (flatRate < h1 || flatRate > h2) {
Assert.Fail("implied hazard rate outside expected range\n"
+ " maturity: " + n + " years\n"
+ " expected minimum: " + h1 + "\n"
+ " expected maximum: " + h2 + "\n"
+ " implied rate: " + flatRate);
}
if (n > 6 && flatRate < latestRate) {
Assert.Fail("implied hazard rate decreasing with swap maturity\n"
+ " maturity: " + n + " years\n"
+ " previous rate: " + latestRate + "\n"
+ " implied rate: " + flatRate);
}
latestRate = flatRate;
RelinkableHandle<DefaultProbabilityTermStructure> probability = new RelinkableHandle<DefaultProbabilityTermStructure>();
probability.linkTo(new FlatHazardRate( today,new Handle<Quote>(new SimpleQuote(flatRate)),dayCounter));
CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, cdsDayCount,true, true);
cds2.setPricingEngine(new MidPointCdsEngine(probability,recoveryRate,discountCurve));
double NPV2 = cds2.NPV();
double tolerance = 1.0;
if (Math.Abs(NPV-NPV2) > tolerance) {
Assert.Fail("failed to reproduce NPV with implied rate\n"
+ " expected: " + NPV + "\n"
+ " calculated: " + NPV2);
}
}
}
public void testCachedMarketValue()
{
// Testing credit-default swap against cached market values...
SavedSettings backup = new SavedSettings();
Settings.setEvaluationDate(new Date(9,Month.June,2006));
Date evalDate = Settings.evaluationDate();
Calendar calendar = new UnitedStates();
List<Date> discountDates = new List<Date>();
discountDates.Add(evalDate);
discountDates.Add(calendar.advance(evalDate, 1, TimeUnit.Weeks, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 1, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 2, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 3, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 6, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate,12, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 2, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 3, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 4, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 5, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 6, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 7, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 8, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate, 9, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate,10, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
discountDates.Add(calendar.advance(evalDate,15, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
List<double> dfs = new List<double>();
dfs.Add(1.0);
dfs.Add(0.9990151375768731);
dfs.Add(0.99570502636871183);
dfs.Add(0.99118260474528685);
dfs.Add(0.98661167950906203);
dfs.Add(0.9732592953359388 );
dfs.Add(0.94724424481038083);
dfs.Add(0.89844996737120875 );
dfs.Add(0.85216647839921411 );
dfs.Add(0.80775477692556874 );
dfs.Add(0.76517289234200347 );
dfs.Add(0.72401019553182933 );
dfs.Add(0.68503909569219212 );
dfs.Add(0.64797499814013748 );
dfs.Add(0.61263171936255534 );
dfs.Add(0.5791942350748791 );
dfs.Add(0.43518868769953606 );
DayCounter curveDayCounter = new Actual360();
RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();
discountCurve.linkTo( new InterpolatedDiscountCurve<LogLinear>( discountDates, dfs, curveDayCounter,null,null,null,new LogLinear() ) );
DayCounter dayCounter = new Thirty360();
List<Date> dates = new List<Date>();
dates.Add(evalDate);
dates.Add(calendar.advance(evalDate, 6, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 1, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 2, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 3, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 4, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 5, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate, 7, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
dates.Add(calendar.advance(evalDate,10, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
List<double> defaultProbabilities = new List<double>();
defaultProbabilities.Add(0.0000);
defaultProbabilities.Add(0.0047);
defaultProbabilities.Add(0.0093);
defaultProbabilities.Add(0.0286);
defaultProbabilities.Add(0.0619);
defaultProbabilities.Add(0.0953);
defaultProbabilities.Add(0.1508);
defaultProbabilities.Add(0.2288);
defaultProbabilities.Add(0.3666);
List<double> hazardRates = new List<double>();
hazardRates.Add(0.0);
for (int i=1; i<dates.Count; ++i)
{
double t1 = dayCounter.yearFraction(dates[0], dates[i-1]);
double t2 = dayCounter.yearFraction(dates[0], dates[i]);
double S1 = 1.0 - defaultProbabilities[i-1];
double S2 = 1.0 - defaultProbabilities[i];
hazardRates.Add(Math.Log(S1/S2)/(t2-t1));
}
RelinkableHandle<DefaultProbabilityTermStructure> piecewiseFlatHazardRate = new RelinkableHandle<DefaultProbabilityTermStructure>();
piecewiseFlatHazardRate.linkTo(new InterpolatedHazardRateCurve<BackwardFlat>(dates,hazardRates,new Thirty360()));
// Testing credit default swap
// Build the schedule
Date issueDate = new Date(20, Month.March, 2006);
Date maturity = new Date(20, Month.June, 2013);
Frequency cdsFrequency = Frequency.Semiannual;
BusinessDayConvention cdsConvention = BusinessDayConvention.ModifiedFollowing;
Schedule schedule = new Schedule(issueDate, maturity, new Period(cdsFrequency), calendar,
cdsConvention, cdsConvention,
DateGeneration.Rule.Forward, false);
// Build the CDS
double recoveryRate = 0.25;
double fixedRate=0.0224;
DayCounter dayCount= new Actual360();
double cdsNotional=100.0;
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, cdsNotional, fixedRate,
schedule, cdsConvention, dayCount, true, true);
cds.setPricingEngine(new MidPointCdsEngine(piecewiseFlatHazardRate, recoveryRate,discountCurve));
double calculatedNpv = cds.NPV();
double calculatedFairRate = cds.fairSpread();
double npv = -1.364048777; // from Bloomberg we have 98.15598868 - 100.00;
double fairRate = 0.0248429452; // from Bloomberg we have 0.0258378;
double tolerance = 1e-9;
if (Math.Abs(npv - calculatedNpv) > tolerance)
Assert.Fail(
"Failed to reproduce the npv for the given credit-default swap\n"
+ " computed NPV: " + calculatedNpv + "\n"
+ " Given NPV: " + npv);
if ( Math.Abs( fairRate - calculatedFairRate ) > tolerance )
Assert.Fail( "Failed to reproduce the fair rate for the given credit-default swap\n"
+ " computed fair rate: " + calculatedFairRate + "\n"
+ " Given fair rate: " + fairRate );
}
public void testCachedValue()
{
// Testing credit-default swap against cached values...
SavedSettings backup = new SavedSettings();
// Initialize curves
Settings.setEvaluationDate(new Date(9,Month.June,2006));
Date today = Settings.evaluationDate();
Calendar calendar = new TARGET();
Handle<Quote> hazardRate = new Handle<Quote>(new SimpleQuote(0.01234));
RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve = new RelinkableHandle<DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));
RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today,0.06,new Actual360()));
// Build the schedule
Date issueDate = calendar.advance(today, -1, TimeUnit.Years);
Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
Frequency frequency = Frequency.Semiannual;
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
convention, convention, DateGeneration.Rule.Forward, false);
// Build the CDS
double fixedRate = 0.0120;
DayCounter dayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, dayCount, true, true);
cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve,recoveryRate,discountCurve));
double npv = 295.0153398;
double fairRate = 0.007517539081;
double calculatedNpv = cds.NPV();
double calculatedFairRate = cds.fairSpread();
double tolerance = 1.0e-7;
if (Math.Abs(calculatedNpv - npv) > tolerance)
Assert.Fail(
"Failed to reproduce NPV with mid-point engine\n"
+ " calculated NPV: " + calculatedNpv + "\n"
+ " expected NPV: " + npv);
if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
Assert.Fail(
"Failed to reproduce fair rate with mid-point engine\n"
+ " calculated fair rate: " + calculatedFairRate + "\n"
+ " expected fair rate: " + fairRate);
cds.setPricingEngine(new IntegralCdsEngine(new Period(1,TimeUnit.Days),probabilityCurve,
recoveryRate,discountCurve));
calculatedNpv = cds.NPV();
calculatedFairRate = cds.fairSpread();
tolerance = 1.0e-5;
if (Math.Abs(calculatedNpv - npv) > notional*tolerance*10)
Assert.Fail(
"Failed to reproduce NPV with integral engine "
+ "(step = 1 day)\n"
+ " calculated NPV: " + calculatedNpv + "\n"
+ " expected NPV: " + npv);
if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
Assert.Fail(
"Failed to reproduce fair rate with integral engine "
+ "(step = 1 day)\n"
+ " calculated fair rate: " + calculatedFairRate + "\n"
+ " expected fair rate: " + fairRate);
cds.setPricingEngine(new IntegralCdsEngine(new Period(1,TimeUnit.Weeks),probabilityCurve,recoveryRate,discountCurve));
calculatedNpv = cds.NPV();
calculatedFairRate = cds.fairSpread();
tolerance = 1.0e-5;
if (Math.Abs(calculatedNpv - npv) > notional*tolerance*10)
Assert.Fail(
"Failed to reproduce NPV with integral engine "
+"(step = 1 week)\n"
+ " calculated NPV: " + calculatedNpv + "\n"
+ " expected NPV: " + npv);
if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
Assert.Fail(
"Failed to reproduce fair rate with integral engine "
+"(step = 1 week)\n"
+ " calculated fair rate: " + calculatedFairRate + "\n"
+ " expected fair rate: " + fairRate);
}
void testBootstrapFromUpfront <T, I>()
where T : ITraits <DefaultProbabilityTermStructure>, new()
where I : class, IInterpolationFactory, new()
{
Calendar calendar = new TARGET();
Date today = Settings.Instance.evaluationDate();
int settlementDays = 1;
List <double> quote = new List <double>();
quote.Add(0.01);
quote.Add(0.02);
quote.Add(0.04);
quote.Add(0.06);
List <int> n = new List <int>();
n.Add(2);
n.Add(3);
n.Add(5);
n.Add(7);
double fixedRate = 0.05;
Frequency frequency = Frequency.Quarterly;
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
DateGeneration.Rule rule = DateGeneration.Rule.CDS;
DayCounter dayCounter = new Actual360();
double recoveryRate = 0.4;
int upfrontSettlementDays = 3;
RelinkableHandle <YieldTermStructure> discountCurve = new RelinkableHandle <YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today, 0.06, new Actual360()));
List <CdsHelper> helpers = new List <CdsHelper>();
for (int i = 0; i < n.Count; i++)
{
helpers.Add(
new UpfrontCdsHelper(quote[i], fixedRate,
new Period(n[i], TimeUnit.Years),
settlementDays, calendar,
frequency, convention, rule,
dayCounter, recoveryRate,
discountCurve,
upfrontSettlementDays,
true, true, null, new Actual360(true)));
}
RelinkableHandle <DefaultProbabilityTermStructure> piecewiseCurve = new RelinkableHandle <DefaultProbabilityTermStructure>();
piecewiseCurve.linkTo(new PiecewiseDefaultCurve <T, I>(today, helpers, new Thirty360()));
double notional = 1.0;
double tolerance = 1.0e-6;
SavedSettings backup = new SavedSettings();
// ensure apple-to-apple comparison
Settings.Instance.includeTodaysCashFlows = true;
for (int i = 0; i < n.Count; i++)
{
Date protectionStart = today + settlementDays;
Date startDate = calendar.adjust(protectionStart, convention);
Date endDate = today + new Period(n[i], TimeUnit.Years);
Date upfrontDate = calendar.advance(today,
upfrontSettlementDays,
TimeUnit.Days,
convention);
Schedule schedule = new Schedule(startDate, endDate, new Period(frequency), calendar,
convention, BusinessDayConvention.Unadjusted, rule, false);
schedule.isRegular().Insert(0, schedule.isRegular()[0]);
schedule.dates().Insert(0, protectionStart);
CreditDefaultSwap cds = new CreditDefaultSwap(CreditDefaultSwap.Protection.Side.Buyer, notional,
quote[i], fixedRate,
schedule, convention, dayCounter,
true, true, protectionStart,
upfrontDate,
null,
new Actual360(true),
true);
cds.setPricingEngine(new MidPointCdsEngine(piecewiseCurve, recoveryRate,
discountCurve, true));
// test
double inputUpfront = quote[i];
double computedUpfront = cds.fairUpfront();
if (Math.Abs(inputUpfront - computedUpfront) > tolerance)
{
QAssert.Fail(
"\nFailed to reproduce fair upfront for " + n[i] +
"Y credit-default swaps\n"
+ " computed: " + computedUpfront.ToString() + "\n"
+ " expected: " + inputUpfront.ToString());
}
}
backup.Dispose();
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CreditDefaultSwap obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CreditDefaultSwap obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
protected void OnVisit(CreditDefaultSwap instrument)
{
_result = string.Format("Credit Default Swap: {0}", this.ConvertSymbol(instrument.Symbol));
}
protected void OnVisit(CreditDefaultSwap instrument)
{
_result = string.Format("Tenor: {0}, Spread: {1:#0}bps", instrument.Tenor, instrument.Spread * 10000);
}
public void testCachedValue()
{
// Testing credit-default swap against cached values...
using (SavedSettings backup = new SavedSettings())
{
// Initialize curves
Settings.setEvaluationDate(new Date(9, Month.June, 2006));
Date today = Settings.evaluationDate();
Calendar calendar = new TARGET();
Handle <Quote> hazardRate = new Handle <Quote>(new SimpleQuote(0.01234));
RelinkableHandle <DefaultProbabilityTermStructure> probabilityCurve = new RelinkableHandle <DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));
RelinkableHandle <YieldTermStructure> discountCurve = new RelinkableHandle <YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today, 0.06, new Actual360()));
// Build the schedule
Date issueDate = calendar.advance(today, -1, TimeUnit.Years);
Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
Frequency frequency = Frequency.Semiannual;
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
convention, convention, DateGeneration.Rule.Forward, false);
// Build the CDS
double fixedRate = 0.0120;
DayCounter dayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
schedule, convention, dayCount, true, true);
cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve));
double npv = 295.0153398;
double fairRate = 0.007517539081;
double calculatedNpv = cds.NPV();
double calculatedFairRate = cds.fairSpread();
double tolerance = 1.0e-7;
if (Math.Abs(calculatedNpv - npv) > tolerance)
{
Assert.Fail(
"Failed to reproduce NPV with mid-point engine\n"
+ " calculated NPV: " + calculatedNpv + "\n"
+ " expected NPV: " + npv);
}
if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
{
Assert.Fail(
"Failed to reproduce fair rate with mid-point engine\n"
+ " calculated fair rate: " + calculatedFairRate + "\n"
+ " expected fair rate: " + fairRate);
}
cds.setPricingEngine(new IntegralCdsEngine(new Period(1, TimeUnit.Days), probabilityCurve,
recoveryRate, discountCurve));
calculatedNpv = cds.NPV();
calculatedFairRate = cds.fairSpread();
tolerance = 1.0e-5;
if (Math.Abs(calculatedNpv - npv) > notional * tolerance * 10)
{
Assert.Fail(
"Failed to reproduce NPV with integral engine "
+ "(step = 1 day)\n"
+ " calculated NPV: " + calculatedNpv + "\n"
+ " expected NPV: " + npv);
}
if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
{
Assert.Fail(
"Failed to reproduce fair rate with integral engine "
+ "(step = 1 day)\n"
+ " calculated fair rate: " + calculatedFairRate + "\n"
+ " expected fair rate: " + fairRate);
}
cds.setPricingEngine(new IntegralCdsEngine(new Period(1, TimeUnit.Weeks), probabilityCurve, recoveryRate, discountCurve));
calculatedNpv = cds.NPV();
calculatedFairRate = cds.fairSpread();
tolerance = 1.0e-5;
if (Math.Abs(calculatedNpv - npv) > notional * tolerance * 10)
{
Assert.Fail(
"Failed to reproduce NPV with integral engine "
+ "(step = 1 week)\n"
+ " calculated NPV: " + calculatedNpv + "\n"
+ " expected NPV: " + npv);
}
if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
{
Assert.Fail(
"Failed to reproduce fair rate with integral engine "
+ "(step = 1 week)\n"
+ " calculated fair rate: " + calculatedFairRate + "\n"
+ " expected fair rate: " + fairRate);
}
}
}
public void testFairUpfront()
{
// Testing fair-upfront calculation for credit-default swaps...
using (SavedSettings backup = new SavedSettings())
{
// Initialize curves
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
Handle <Quote> hazardRate = new Handle <Quote>(new SimpleQuote(0.01234));
RelinkableHandle <DefaultProbabilityTermStructure> probabilityCurve =
new RelinkableHandle <DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));
RelinkableHandle <YieldTermStructure> discountCurve =
new RelinkableHandle <YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today, 0.06, new Actual360()));
// Build the schedule
Date issueDate = today;
Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
BusinessDayConvention convention = BusinessDayConvention.Following;
Schedule schedule =
new MakeSchedule().from(issueDate)
.to(maturity)
.withFrequency(Frequency.Quarterly)
.withCalendar(calendar)
.withTerminationDateConvention(convention)
.withRule(DateGeneration.Rule.TwentiethIMM).value();
// Build the CDS
double fixedRate = 0.05;
double upfront = 0.001;
DayCounter dayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
IPricingEngine engine = new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve, true);
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, upfront, fixedRate,
schedule, convention, dayCount, true, true);
cds.setPricingEngine(engine);
double fairUpfront = cds.fairUpfront();
CreditDefaultSwap fairCds = new CreditDefaultSwap(Protection.Side.Seller, notional,
fairUpfront, fixedRate, schedule, convention, dayCount, true, true);
fairCds.setPricingEngine(engine);
double fairNPV = fairCds.NPV();
double tolerance = 1e-10;
if (Math.Abs(fairNPV) > tolerance)
{
Assert.Fail(
"Failed to reproduce null NPV with calculated fair upfront\n"
+ " calculated upfront: " + fairUpfront + "\n"
+ " calculated NPV: " + fairNPV);
}
// same with null upfront to begin with
upfront = 0.0;
CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, upfront, fixedRate,
schedule, convention, dayCount, true, true);
cds2.setPricingEngine(engine);
fairUpfront = cds2.fairUpfront();
CreditDefaultSwap fairCds2 = new CreditDefaultSwap(Protection.Side.Seller, notional,
fairUpfront, fixedRate, schedule, convention, dayCount, true, true);
fairCds2.setPricingEngine(engine);
fairNPV = fairCds2.NPV();
if (Math.Abs(fairNPV) > tolerance)
{
Assert.Fail(
"Failed to reproduce null NPV with calculated fair upfront\n"
+ " calculated upfront: " + fairUpfront + "\n"
+ " calculated NPV: " + fairNPV);
}
}
}
public void testFairUpfront()
{
// Testing fair-upfront calculation for credit-default swaps...
SavedSettings backup = new SavedSettings();
// Initialize curves
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
Handle<Quote> hazardRate = new Handle<Quote>(new SimpleQuote(0.01234));
RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve =
new RelinkableHandle<DefaultProbabilityTermStructure>();
probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));
RelinkableHandle<YieldTermStructure> discountCurve =
new RelinkableHandle<YieldTermStructure>();
discountCurve.linkTo(new FlatForward(today,0.06,new Actual360()));
// Build the schedule
Date issueDate = today;
Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
BusinessDayConvention convention = BusinessDayConvention.Following;
Schedule schedule =
new MakeSchedule().from(issueDate)
.to(maturity)
.withFrequency(Frequency.Quarterly)
.withCalendar(calendar)
.withTerminationDateConvention(convention)
.withRule(DateGeneration.Rule.TwentiethIMM).value();
// Build the CDS
double fixedRate = 0.05;
double upfront = 0.001;
DayCounter dayCount = new Actual360();
double notional = 10000.0;
double recoveryRate = 0.4;
IPricingEngine engine = new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve, true);
CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, upfront, fixedRate,
schedule, convention, dayCount, true, true);
cds.setPricingEngine(engine);
double fairUpfront = cds.fairUpfront();
CreditDefaultSwap fairCds = new CreditDefaultSwap(Protection.Side.Seller, notional,
fairUpfront, fixedRate, schedule, convention, dayCount, true, true);
fairCds.setPricingEngine(engine);
double fairNPV = fairCds.NPV();
double tolerance = 1e-10;
if (Math.Abs(fairNPV) > tolerance)
Assert.Fail(
"Failed to reproduce null NPV with calculated fair upfront\n"
+ " calculated upfront: " + fairUpfront + "\n"
+ " calculated NPV: " + fairNPV);
// same with null upfront to begin with
upfront = 0.0;
CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, upfront, fixedRate,
schedule, convention, dayCount, true, true);
cds2.setPricingEngine(engine);
fairUpfront = cds2.fairUpfront();
CreditDefaultSwap fairCds2 = new CreditDefaultSwap(Protection.Side.Seller, notional,
fairUpfront, fixedRate, schedule, convention, dayCount, true, true);
fairCds2.setPricingEngine(engine);
fairNPV = fairCds2.NPV();
if (Math.Abs(fairNPV) > tolerance)
Assert.Fail(
"Failed to reproduce null NPV with calculated fair upfront\n"
+ " calculated upfront: " + fairUpfront + "\n"
+ " calculated NPV: " + fairNPV);
}
