public void SABRInterpolateVolatilityTest()
{
Swaption target = Swaption.Instance();
target.SabrAddCalibrationSetting(_settingsHandle, _instrument, _ccy, _beta);
target.SABRCalibrateModel(_engineHandle, _settingsHandle, _volatilityData, _assetData, _optionExpiry);
// Used to be this, not any more for some reason...
//decimal expected = 0.1003227242714797260490536807m;
double expected = 0.10;
decimal actual = target.SABRInterpolateVolatility(_engineHandle, _exerciseTime, _assetCode, _strike);
Assert.AreEqual(expected, (double)actual, 0.01);
}
public Swaption value()
{
Date evaluationDate = Settings.evaluationDate();
Calendar fixingCalendar = swapIndex_.fixingCalendar();
fixingDate_ = fixingCalendar.advance(evaluationDate, optionTenor_, optionConvention_);
if (exerciseDate_ == null)
{
exercise_ = new EuropeanExercise(fixingDate_);
}
else
{
Utils.QL_REQUIRE(exerciseDate_ <= fixingDate_, () =>
"exercise date (" + exerciseDate_ + ") must be less " + "than or equal to fixing date (" + fixingDate_ + ")");
exercise_ = new EuropeanExercise(exerciseDate_);
}
double usedStrike;
if (strike_ == null)
{
// ATM on the forecasting curve
Utils.QL_REQUIRE(!swapIndex_.forwardingTermStructure().empty(), () =>
"no forecasting term structure set to " + swapIndex_.name());
VanillaSwap temp = swapIndex_.underlyingSwap(fixingDate_);
temp.setPricingEngine(new DiscountingSwapEngine(swapIndex_.forwardingTermStructure()));
usedStrike = temp.fairRate();
}
else
{
usedStrike = strike_.Value;
}
BusinessDayConvention bdc = swapIndex_.fixedLegConvention();
underlyingSwap_ = new MakeVanillaSwap(swapIndex_.tenor(),
swapIndex_.iborIndex(),
usedStrike)
.withEffectiveDate(swapIndex_.valueDate(fixingDate_))
.withFixedLegCalendar(swapIndex_.fixingCalendar())
.withFixedLegDayCount(swapIndex_.dayCounter())
.withFixedLegConvention(bdc)
.withFixedLegTerminationDateConvention(bdc);
Swaption swaption = new Swaption(underlyingSwap_, exercise_, delivery_);
swaption.setPricingEngine(engine_);
return(swaption);
}
public SwaptionHelper(Period maturity,
Period length,
Handle<Quote> volatility,
IborIndex index,
Period fixedLegTenor,
DayCounter fixedLegDayCounter,
DayCounter floatingLegDayCounter,
Handle<YieldTermStructure> termStructure,
bool calibrateVolatility /*= false*/)
: base(volatility,termStructure, calibrateVolatility) {
Calendar calendar = index.fixingCalendar();
Period indexTenor = index.tenor();
int fixingDays = index.fixingDays();
Date exerciseDate = calendar.advance(termStructure.link.referenceDate(),
maturity,
index.businessDayConvention());
Date startDate = calendar.advance(exerciseDate,
fixingDays, TimeUnit.Days,
index.businessDayConvention());
Date 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);
VanillaSwap temp=new VanillaSwap(VanillaSwap.Type.Receiver, 1.0,
fixedSchedule, 0.0, fixedLegDayCounter,
floatSchedule, index, 0.0, floatingLegDayCounter);
temp.setPricingEngine(swapEngine);
exerciseRate_ = temp.fairRate();
swap_ = new VanillaSwap(VanillaSwap.Type.Receiver, 1.0,
fixedSchedule, exerciseRate_, fixedLegDayCounter,
floatSchedule, index, 0.0, floatingLegDayCounter);
swap_.setPricingEngine(swapEngine);
Exercise exercise=new EuropeanExercise(exerciseDate);
swaption_ = new Swaption(swap_, exercise);
marketValue_ = blackPrice(volatility_.link.value());
}
public DiscretizedSwaption(Swaption.Arguments args,
Date referenceDate,
DayCounter dayCounter)
: base(new DiscretizedSwap(args, referenceDate, dayCounter), args.exercise.type(), new List<double>())
{
arguments_=args;
exerciseTimes_ = new InitializedList<double>(arguments_.exercise.dates().Count);
for (int i = 0; i < exerciseTimes_.Count; ++i)
exerciseTimes_[i] =
dayCounter.yearFraction(referenceDate,
arguments_.exercise.date(i));
// Date adjustments can get time vectors out of synch.
// Here, we try and collapse similar dates which could cause
// a mispricing.
for (int i=0; i<arguments_.exercise.dates().Count; i++) {
Date exerciseDate = arguments_.exercise.date(i);
for (int j = 0; j < arguments_.fixedPayDates.Count; j++) {
if (withinNextWeek(exerciseDate,
arguments_.fixedPayDates[j])
// coupons in the future are dealt with below
&& arguments_.fixedResetDates[j] < referenceDate)
arguments_.fixedPayDates[j] = exerciseDate;
}
for (int j = 0; j < arguments_.fixedResetDates.Count; j++) {
if (withinPreviousWeek(exerciseDate,
arguments_.fixedResetDates[j]))
arguments_.fixedResetDates[j] = exerciseDate;
}
for (int j = 0; j < arguments_.floatingResetDates.Count; j++) {
if (withinPreviousWeek(exerciseDate,
arguments_.floatingResetDates[j]))
arguments_.floatingResetDates[j] = exerciseDate;
}
}
double lastFixedPayment =
dayCounter.yearFraction(referenceDate,
arguments_.fixedPayDates.Last() );
double lastFloatingPayment =
dayCounter.yearFraction(referenceDate,
arguments_.floatingPayDates.Last());
lastPayment_ = Math.Max(lastFixedPayment,lastFloatingPayment);
underlying_ = new DiscretizedSwap(arguments_,
referenceDate,
dayCounter);
}
static void Main(string[] args)
{
var n = new ConstantNotionalSchedule();
var swaption = new Swaption {
Notional = n,
StartDate = new KDateTime(2000, 1, 1),
EndDate = new KDateTime(2020, 1, 1),
Ccy = Common.Ccy.EUR,
PoR = PayRecieve.P
};
System.Console.WriteLine(swaption);
System.Console.ReadLine();
}
public void SABRCalibrateATMModelTest()
{
Swaption target = Swaption.Instance();
string expected = _atmEngineHandle;
target.SabrAddCalibrationSetting(_settingsHandle, _instrument, _ccy, _beta);
string actual = target.SABRCalibrateATMModel(_atmEngineHandle, _settingsHandle, _nu, _rho, _atmVolatility, _assetPrice, _exerciseTime, _assetCode);
Assert.AreEqual(expected, actual);
// Test the IsCalibrated status - true if the Function succeeded
// Use default expiry/tenor pair
bool testStatus = target.IsModelCalibrated(_atmEngineHandle, _optionExpiry, _tenor);
Assert.AreEqual(true, testStatus);
}
//-------------------------------------------------------------------------
public virtual FunctionRequirements requirements(SwaptionTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
// extract data from product
Swaption product = trade.Product;
Currency currency = product.Currency;
IborIndex index = product.Index;
// use lookup to build requirements
RatesMarketDataLookup ratesLookup = parameters.getParameter(typeof(RatesMarketDataLookup));
FunctionRequirements ratesReqs = ratesLookup.requirements(currency, index);
SwaptionMarketDataLookup swaptionLookup = parameters.getParameter(typeof(SwaptionMarketDataLookup));
FunctionRequirements swaptionReqs = swaptionLookup.requirements(index);
return(ratesReqs.combinedWith(swaptionReqs));
}
public void SwaptionCallPrice()
{
var t = 4;
var m = 2;
var F = 0.07;
var K = 0.075;
var T = 2;
var r = 0.06;
var v = 0.2;
var option = new Swaption(t, F, K, r, T, v, m, OptionType.Call);
var swaptionPrice = option.Price(F);
Assert.AreEqual(0.01796, swaptionPrice, 0.01);
}
public void SABRCalibrateModelTest()
{
Swaption target = Swaption.Instance();
target.SabrAddCalibrationSetting(_settingsHandle, _instrument, _ccy, _beta);
string actual = target.SABRCalibrateModel(_engineHandle, _settingsHandle, _volatilityData, _assetData, _optionExpiry);
string expected = _engineHandle;
Assert.AreEqual(expected, actual);
// Test the IsCalibrated status - true if the Function succeeded
// Use default expiry/tenor pair
bool testStatus = target.IsModelCalibrated(_engineHandle, _optionExpiry, _tenor);
Assert.AreEqual(true, testStatus);
// Test a non-existent expiry/tenor pair
testStatus = target.IsModelCalibrated(_engineHandle, "4yr", "3");
Assert.AreEqual(false, testStatus);
}
public void C3_14_2_B_SwaptionPutPrice()
{
//var b = 0;
var T = 2;
var K = 0.075;
var r = 0.06;
var sig = 0.2;
var F = 0.07;
var m = 2;
var t = 4;
var option = new Swaption(OptionType.Put, T, K, r, sig, t, m);
var swaptionPrice = option.Price(F);
Assert.AreEqual(0.033, swaptionPrice, 0.01);
}
public static object CouponDataReport(Swaption interestRateSwaption)
{
if (interestRateSwaption != null)
{
var interestRateSwap = interestRateSwaption.swap;
var coupons1 = interestRateSwap.swapStream[0].cashflows.paymentCalculationPeriod.Length;
//var pe1 = 0;
//if(interestRateSwap.swapStream[0].cashflows.principalExchange!=null)
//{
// pe1 = interestRateSwap.swapStream[0].cashflows.principalExchange.Length;
//}
var coupons2 = interestRateSwap.swapStream[1].cashflows.paymentCalculationPeriod.Length;
//var pe2 = 0;
//if (interestRateSwap.swapStream[1].cashflows.principalExchange != null)
//{
// pe2 = interestRateSwap.swapStream[1].cashflows.principalExchange.Length;
//}
var result = new object[coupons1 + coupons2, 4];
var index = 0;
foreach (var coupon1 in interestRateSwap.swapStream[0].cashflows.paymentCalculationPeriod)
{
result[index, 0] = "Leg1_Coupon_" + index;
result[index, 1] = coupon1.adjustedPaymentDate;
result[index, 2] = coupon1.discountFactor;
result[index, 3] = coupon1.forecastPaymentAmount.amount;
result[index, 4] = coupon1.forecastPaymentAmount.currency.Value;
index++;
}
var secondIndex = 0;
foreach (var coupon2 in interestRateSwap.swapStream[1].cashflows.paymentCalculationPeriod)
{
result[index, 0] = "Leg2_Coupon_" + secondIndex;
result[index, 1] = coupon2.adjustedPaymentDate;
result[index, 2] = coupon2.discountFactor;
result[index, 3] = coupon2.forecastPaymentAmount.amount;
result[index, 4] = coupon2.forecastPaymentAmount.currency.Value;
index++;
secondIndex++;
}
return(result);
}
return(null);
}
public static Swaption Create(Swap swap, Payment[] premium, EuropeanExercise exercise, bool automaticExercise)
{
var swaption = new Swaption {
swap = swap, premium = premium
};
var europeanExercise = exercise;
swaption.exerciseProcedure = new ExerciseProcedure();
if (automaticExercise)
{
XsdClassesFieldResolver.ExerciseProcedureSetAutomaticExercise(swaption.exerciseProcedure, new AutomaticExercise());
}
else//manual exercise
{
XsdClassesFieldResolver.ExerciseProcedureSetManualExercise(swaption.exerciseProcedure, new ManualExercise());
}
XsdClassesFieldResolver.SwaptionSetEuropeanExercise(swaption, europeanExercise);
return(swaption);
}
public void TestPayerSwaption()
{
var swap = new PlainVanillaInterestRateSwap();
swap.Tenor = 4;
swap.YearlyFloatPaymentCount = 2;
swap.FloatRate = 0.07;
swap.FixedRate = 0.075;
var swaption = new Swaption(swap);
swaption.Underlying = swap;
swaption.Strike = swap.FixedRate;
swaption.TimeToMaturity = 2;
swaption.Volatility = 0.2;
var r = 0.06;
BlackScholesPricer.ComputeEuropeanPayerSwaptionPrice(swaption, r);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="swaptionFpML"> </param>
/// <param name="basePartyReference"></param>
/// <param name="forecastRateInterpolation"></param>
public InterestRateSwaptionPricer(ILogger logger, ICoreCache cache, String nameSpace,
Swaption swaptionFpML, string basePartyReference, Boolean forecastRateInterpolation)
: base(logger, cache, nameSpace, swaptionFpML, basePartyReference, forecastRateInterpolation)
{
ProductType = ProductTypeSimpleEnum.InterestRateSwaption;
var underlyingSwap = new InterestRateSwapPricer(logger, cache, nameSpace, null, swaptionFpML.swap, basePartyReference, forecastRateInterpolation);
Swap = underlyingSwap;
//Add the currencies for the trade pricer.
foreach (var ccy in Swap.PaymentCurrencies)
{
if (!PaymentCurrencies.Contains(ccy))
{
PaymentCurrencies.Add(ccy);
}
}
if (underlyingSwap.SwapType == SwapType.FixedFloat && underlyingSwap.ProductType == ProductTypeSimpleEnum.InterestRateSwap)
{
if (Swap.BasePartyPayingFixed && underlyingSwap.PayLeg.Strike != null)
{
StrikeRate = (decimal)underlyingSwap.PayLeg.Strike;
if (!IsBasePartyBuyer)
{
IsCall = true;
}
}
if (!Swap.BasePartyPayingFixed && underlyingSwap.ReceiveLeg.Strike != null)//
{
StrikeRate = (decimal)underlyingSwap.ReceiveLeg.Strike;
if (IsBasePartyBuyer)
{
IsCall = true;
}
}
VolatilitySurfaceName = CurveNameHelpers.GetRateVolatilityMatrixName(swaptionFpML.swap);
}
BucketedDates = new DateTime[] { };
RiskMaturityDate = Swap.RiskMaturityDate;
}
public double[] SwaptionPrices(Swaption swo)
{
var ret = new List <double>();
double r0 = dc.ForwardRate(0.01);
List <IEnumerable <IState> > pathsToStrike = Enumerable.Range(0, n).Select(_ => process.generatePathFrom(new RSProcess.State(r0, 0), 0, step, swo.ExecutionTime)).ToList();
foreach (var path in pathsToStrike)
{
double zbp = 1;
foreach (var x in path)
{
zbp *= Math.Exp(-x.r * step);
}
ret.Add(
Math.Max(swo.UnderlyingSwap.Price(process, path.Last(), swo.ExecutionTime, step, (int)Math.Sqrt(n)), 0) * zbp
);
}
return(ret.ToArray());
}
public static Swaption Create(Swap swap, decimal premiumAmount, DateTime expirationDate)
{
var swaption = new Swaption {
swap = swap, premium = new[] { new Payment() }
};
swaption.premium[0].paymentAmount = MoneyHelper.GetNonNegativeAmount(premiumAmount);
var europeanExercise = new EuropeanExercise
{
expirationDate = new AdjustableOrRelativeDate()
};
var adjustableDate = new AdjustableDate
{
unadjustedDate = new IdentifiedDate
{
Value = expirationDate
}
};
europeanExercise.expirationDate.Item = adjustableDate;
XsdClassesFieldResolver.SwaptionSetEuropeanExercise(swaption, europeanExercise);
return(swaption);
}
public static ValuationReport Generate(string valuationId, string baseParty,
string tradeId, DateTime tradeDate,
Swaption swaption, Market market, AssetValuation assetValuation)
{
var valuationReport = new ValuationReport
{
header = new NotificationMessageHeader
{
messageId = new MessageId
{
Value
=
valuationId
}
},
market = market
};
// Associate id with the valuation
//
var tradeValuationItem = new TradeValuationItem();
valuationReport.tradeValuationItem = new[] { tradeValuationItem };
// Generate trade header
//
var trade = new Trade();
TradeHeader tradeHeader = CreateTradeHeader(tradeDate, tradeId);
trade.tradeHeader = tradeHeader;
XsdClassesFieldResolver.TradeSetSwaption(trade, swaption);
tradeValuationItem.Items = new object[] { trade };
tradeValuationItem.valuationSet = new ValuationSet
{
baseParty = PartyReferenceFactory.Create(baseParty),
assetValuation = new[] { assetValuation }
};
return(valuationReport);
}
public static Swaption Create(Swap swap, NonNegativeMoney premium, string premiumPayer, string premiumReceiver,
AdjustableOrAdjustedDate paymentDate,
AdjustableDate expirationDate,
DateTime earliestExerciseTime, DateTime expirationTime, bool automaticExercise)
{
var swaption = new Swaption
{
swap = swap,
premium = new[] { new Payment() },
buyerPartyReference = PartyReferenceHelper.Parse(premiumPayer),
sellerPartyReference = PartyReferenceHelper.Parse(premiumReceiver)
};
swaption.premium[0].paymentAmount = premium;
swaption.premium[0].paymentDate = paymentDate;
swaption.premium[0].payerPartyReference = PartyReferenceHelper.Parse(premiumPayer);
swaption.premium[0].receiverPartyReference = PartyReferenceHelper.Parse(premiumReceiver);
var europeanExercise = new EuropeanExercise
{
expirationDate = new AdjustableOrRelativeDate(),
earliestExerciseTime = BusinessCenterTimeHelper.Create(earliestExerciseTime),
expirationTime = BusinessCenterTimeHelper.Create(expirationTime)
};
europeanExercise.expirationDate.Item = expirationDate;
swaption.exerciseProcedure = new ExerciseProcedure();
if (automaticExercise)
{
XsdClassesFieldResolver.ExerciseProcedureSetAutomaticExercise(swaption.exerciseProcedure, new AutomaticExercise());
}
else//manual exercise
{
XsdClassesFieldResolver.ExerciseProcedureSetManualExercise(swaption.exerciseProcedure, new ManualExercise());
}
XsdClassesFieldResolver.SwaptionSetEuropeanExercise(swaption, europeanExercise);
return(swaption);
}
public Swaption value()
{
Date evaluationDate = Settings.evaluationDate();
Calendar fixingCalendar = swapIndex_.fixingCalendar();
fixingDate_ = fixingCalendar.advance(evaluationDate, optionTenor_, optionConvention_);
if (exerciseDate_ == null) {
exercise_ =new EuropeanExercise(fixingDate_);
}
else {
if(exerciseDate_ <= fixingDate_)
throw new ArgumentException(
"exercise date (" + exerciseDate_ + ") must be less "+
"than or equal to fixing date (" + fixingDate_ + ")");
exercise_ = new EuropeanExercise(exerciseDate_);
}
double usedStrike = strike_;
if (strike_ == null) {
// ATM on the forecasting curve
if (!swapIndex_.forwardingTermStructure().empty())
throw new ArgumentException(
"no forecasting term structure set to "+swapIndex_.name());
VanillaSwap temp =
swapIndex_.underlyingSwap(fixingDate_);
temp.setPricingEngine(new DiscountingSwapEngine(
swapIndex_.forwardingTermStructure()));
usedStrike = temp.fairRate();
}
BusinessDayConvention bdc = swapIndex_.fixedLegConvention();
underlyingSwap_ =new MakeVanillaSwap( swapIndex_.tenor(),
swapIndex_.iborIndex(),
usedStrike)
.withEffectiveDate(swapIndex_.valueDate(fixingDate_))
.withFixedLegCalendar(swapIndex_.fixingCalendar())
.withFixedLegDayCount(swapIndex_.dayCounter())
.withFixedLegConvention(bdc)
.withFixedLegTerminationDateConvention(bdc);
Swaption swaption=new Swaption(underlyingSwap_, exercise_, delivery_);
swaption.setPricingEngine(engine_);
return swaption;
}
public void testSpreadDependency()
{
//"Testing swaption dependency on spread...";
CommonVars vars = new CommonVars();
double[] spreads = { -0.002, -0.001, 0.0, 0.001, 0.002 };
for (int i = 0; i < exercises.Length; i++)
{
for (int j = 0; j < lengths.Length; j++)
{
for (int k = 0; k < type.Length; k++)
{
Date exerciseDate = vars.calendar.advance(vars.today,
exercises[i]);
Date startDate =
vars.calendar.advance(exerciseDate,
vars.settlementDays, TimeUnit.Days);
// store the results for different rates...
List <double> values = new InitializedList <double>(spreads.Length);
List <double> values_cash = new InitializedList <double>(spreads.Length);
for (int l = 0; l < spreads.Length; l++)
{
VanillaSwap swap =
new MakeVanillaSwap(lengths[j], vars.index, 0.06)
.withEffectiveDate(startDate)
.withFloatingLegSpread(spreads[l])
.withType(type[k]);
Swaption swaption =
vars.makeSwaption(swap, exerciseDate, 0.20);
// FLOATING_POINT_EXCEPTION
values[l] = swaption.NPV();
Swaption swaption_cash =
vars.makeSwaption(swap, exerciseDate, 0.20,
Settlement.Type.Cash);
values_cash[l] = swaption_cash.NPV();
}
// and check that they go the right way
if (type[k] == VanillaSwap.Type.Payer)
{
for (int n = 0; n < spreads.Length - 1; n++)
{
if (values[n] > values[n + 1])
{
Assert.Fail("NPV is decreasing with the spread " +
"in a payer swaption (physical delivered):" +
"\nexercise date: " + exerciseDate +
"\nlength: " + lengths[j] +
"\nvalue: " + values[n] + " for spread: " + spreads[n] +
"\nvalue: " + values[n + 1] + " for spread: " + spreads[n + 1]);
}
if (values_cash[n] > values_cash[n + 1])
{
Assert.Fail("NPV is decreasing with the spread " +
"in a payer swaption (cash delivered):" +
"\nexercise date: " + exerciseDate +
"\nlength: " + lengths[j] +
"\nvalue: " + values_cash[n] + " for spread: " + spreads[n] +
"\nvalue: " + values_cash[n + 1] + " for spread: " + spreads[n + 1]);
}
}
}
else
{
for (int n = 0; n < spreads.Length - 1; n++)
{
if (values[n] < values[n + 1])
{
Assert.Fail("NPV is increasing with the spread " +
"in a receiver swaption (physical delivered):" +
"\nexercise date: " + exerciseDate +
"\nlength: " + lengths[j] +
"\nvalue: " + values[n] + " for spread: " + spreads[n] +
"\nvalue: " + values[n + 1] + " for spread: " + spreads[n + 1]);
}
if (values_cash[n] < values_cash[n + 1])
{
Assert.Fail("NPV is increasing with the spread " +
"in a receiver swaption (cash delivered):" +
"\nexercise date: " + exerciseDate +
"\nlength: " + lengths[j] +
"\nvalue: " + values_cash[n] + " for spread: " + spreads[n] +
"\nvalue: " + values_cash[n + 1] + " for spread: " + spreads[n + 1]);
}
}
}
}
}
}
}
public void testSpreadTreatment()
{
//"Testing swaption treatment of spread...";
CommonVars vars = new CommonVars();
double[] spreads = { -0.002, -0.001, 0.0, 0.001, 0.002 };
for (int i = 0; i < exercises.Length; i++)
{
for (int j = 0; j < lengths.Length; j++)
{
for (int k = 0; k < type.Length; k++)
{
Date exerciseDate = vars.calendar.advance(vars.today,
exercises[i]);
Date startDate =
vars.calendar.advance(exerciseDate,
vars.settlementDays, TimeUnit.Days);
for (int l = 0; l < spreads.Length; l++)
{
VanillaSwap swap =
new MakeVanillaSwap(lengths[j], vars.index, 0.06)
.withEffectiveDate(startDate)
.withFloatingLegSpread(spreads[l])
.withType(type[k]);
// FLOATING_POINT_EXCEPTION
double correction = spreads[l] *
swap.floatingLegBPS() /
swap.fixedLegBPS();
VanillaSwap equivalentSwap =
new MakeVanillaSwap(lengths[j], vars.index, 0.06 + correction)
.withEffectiveDate(startDate)
.withFloatingLegSpread(0.0)
.withType(type[k]);
Swaption swaption1 =
vars.makeSwaption(swap, exerciseDate, 0.20);
Swaption swaption2 =
vars.makeSwaption(equivalentSwap, exerciseDate, 0.20);
Swaption swaption1_cash =
vars.makeSwaption(swap, exerciseDate, 0.20,
Settlement.Type.Cash);
Swaption swaption2_cash =
vars.makeSwaption(equivalentSwap, exerciseDate, 0.20,
Settlement.Type.Cash);
if (Math.Abs(swaption1.NPV() - swaption2.NPV()) > 1.0e-6)
{
Assert.Fail("wrong spread treatment:" +
"\nexercise: " + exerciseDate +
"\nlength: " + lengths[j] +
"\ntype " + type[k] +
"\nspread: " + spreads[l] +
"\noriginal swaption value: " + swaption1.NPV() +
"\nequivalent swaption value: " + swaption2.NPV());
}
if (Math.Abs(swaption1_cash.NPV() - swaption2_cash.NPV()) > 1.0e-6)
{
Assert.Fail("wrong spread treatment:" +
"\nexercise date: " + exerciseDate +
"\nlength: " + lengths[j] +
//"\npay " + (type[k] ? "fixed" : "floating") +
"\nspread: " + spreads[l] +
"\nvalue of original swaption: " + swaption1_cash.NPV() +
"\nvalue of equivalent swaption: " + swaption2_cash.NPV());
}
}
}
}
}
}
public Swaption makeSwaption(VanillaSwap swap,Date exercise,double volatility)
{
Settlement.Type settlementType= Settlement.Type.Physical;
Handle<Quote> vol=new Handle <Quote>(new SimpleQuote(volatility));
IPricingEngine engine=new BlackSwaptionEngine(termStructure, vol);
Swaption result=new Swaption(swap,new EuropeanExercise(exercise),settlementType);
result.setPricingEngine(engine);
return result;
}
public void testImpliedVolatility()
{
//"Testing implied volatility for swaptions...";
CommonVars vars = new CommonVars();
int maxEvaluations = 100;
double tolerance = 1.0e-08;
Settlement.Type[] types = { Settlement.Type.Physical, Settlement.Type.Cash };
// test data
double[] strikes = { 0.02, 0.03, 0.04, 0.05, 0.06, 0.07 };
double[] vols = { 0.01, 0.05, 0.10, 0.20, 0.30, 0.70, 0.90 };
for (int i = 0; i < exercises.Length; i++)
{
for (int j = 0; j < lengths.Length; j++)
{
Date exerciseDate = vars.calendar.advance(vars.today, exercises[i]);
Date startDate = vars.calendar.advance(exerciseDate,
vars.settlementDays, TimeUnit.Days);
Date maturity = vars.calendar.advance(startDate, lengths[j],
vars.floatingConvention);
for (int t = 0; t < strikes.Length; t++)
{
for (int k = 0; k < type.Length; k++)
{
VanillaSwap swap = new MakeVanillaSwap(lengths[j], vars.index, strikes[t])
.withEffectiveDate(startDate)
.withFloatingLegSpread(0.0)
.withType(type[k]);
for (int h = 0; h < types.Length; h++)
{
for (int u = 0; u < vols.Length; u++)
{
Swaption swaption = vars.makeSwaption(swap, exerciseDate,
vols[u], types[h]);
// Black price
double value = swaption.NPV();
double implVol = 0.0;
try
{
implVol =
swaption.impliedVolatility(value,
vars.termStructure,
0.10,
tolerance,
maxEvaluations);
}
catch (System.Exception e)
{
// couldn't bracket?
swaption.setPricingEngine(vars.makeEngine(0.0));
double value2 = swaption.NPV();
if (Math.Abs(value - value2) < tolerance)
{
// ok, just skip:
continue;
}
// otherwise, report error
Assert.Fail("implied vol failure: " +
exercises[i] + "x" + lengths[j] + " " + type[k] +
"\nsettlement: " + types[h] +
"\nstrike " + strikes[t] +
"\natm level: " + swap.fairRate() +
"\nvol: " + vols[u] +
"\nprice: " + value +
"\n" + e.Message.ToString());
}
if (Math.Abs(implVol - vols[u]) > tolerance)
{
// the difference might not matter
swaption.setPricingEngine(vars.makeEngine(implVol));
double value2 = swaption.NPV();
if (Math.Abs(value - value2) > tolerance)
{
Assert.Fail("implied vol failure: " +
exercises[i] + "x" + lengths[j] + " " + type[k] +
"\nsettlement: " + types[h] +
"\nstrike " + strikes[t] +
"\natm level: " + swap.fairRate() +
"\nvol: " + vols[u] +
"\nprice: " + value +
"\nimplied vol: " + implVol +
"\nimplied price: " + value2);
}
}
}
}
}
}
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Swaption obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public void testCachedValues()
{
//("Testing Bermudan swaption against cached values...");
CommonVars vars = new CommonVars();
vars.today = new Date(15, Month.February, 2002);
Settings.setEvaluationDate(vars.today);
vars.settlement = new Date(19, Month.February, 2002);
// flat yield term structure impling 1x5 swap at 5%
vars.termStructure.linkTo(Utilities.flatRate(vars.settlement,
0.04875825,
new Actual365Fixed()));
double atmRate = vars.makeSwap(0.0).fairRate();
VanillaSwap itmSwap = vars.makeSwap(0.8 * atmRate);
VanillaSwap atmSwap = vars.makeSwap(atmRate);
VanillaSwap otmSwap = vars.makeSwap(1.2 * atmRate);
double a = 0.048696, sigma = 0.0058904;
ShortRateModel model = new HullWhite(vars.termStructure, a, sigma);
List <Date> exerciseDates = new List <Date>();
List <CashFlow> leg = atmSwap.fixedLeg();
for (int i = 0; i < leg.Count; i++)
{
Coupon coupon = (Coupon)(leg[i]);
exerciseDates.Add(coupon.accrualStartDate());
}
Exercise exercise = new BermudanExercise(exerciseDates);
IPricingEngine treeEngine = new TreeSwaptionEngine(model, 50);
IPricingEngine fdmEngine = new FdHullWhiteSwaptionEngine(model as HullWhite);
#if QL_USE_INDEXED_COUPON
double itmValue = 42.2413, atmValue = 12.8789, otmValue = 2.4759;
double itmValueFdm = 42.2111, atmValueFdm = 12.8879, otmValueFdm = 2.44443;
#else
double itmValue = 42.2470, atmValue = 12.8826, otmValue = 2.4769;
double itmValueFdm = 42.2091, atmValueFdm = 12.8864, otmValueFdm = 2.4437;
#endif
double tolerance = 1.0e-4;
Swaption swaption = new Swaption(itmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - itmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValue);
}
swaption.setPricingEngine(fdmEngine);
if (Math.Abs(swaption.NPV() - itmValueFdm) > tolerance)
{
QAssert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValueFdm);
}
swaption = new Swaption(atmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - atmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValue);
}
swaption.setPricingEngine(fdmEngine);
if (Math.Abs(swaption.NPV() - atmValueFdm) > tolerance)
{
QAssert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValueFdm);
}
swaption = new Swaption(otmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - otmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValue);
}
swaption.setPricingEngine(fdmEngine);
if (Math.Abs(swaption.NPV() - otmValueFdm) > tolerance)
{
QAssert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValueFdm);
}
for (int j = 0; j < exerciseDates.Count; j++)
{
exerciseDates[j] = vars.calendar.adjust(exerciseDates[j] - 10);
}
exercise = new BermudanExercise(exerciseDates);
#if QL_USE_INDEXED_COUPON
itmValue = 42.1917; atmValue = 12.7788; otmValue = 2.4388;
#else
itmValue = 42.1974; atmValue = 12.7825; otmValue = 2.4399;
#endif
swaption = new Swaption(itmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - itmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValue);
}
swaption = new Swaption(atmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - atmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValue);
}
swaption = new Swaption(otmSwap, exercise);
swaption.setPricingEngine(treeEngine);
if (Math.Abs(swaption.NPV() - otmValue) > tolerance)
{
QAssert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValue);
}
}
public static void TradeSetSwaption(Trade trade, Swaption swaption)
{
trade.Item = swaption;
trade.ItemElementName = ItemChoiceType15.swaption;
}
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();
}
//class Swaption {
// [System.Xml.Serialization.XmlElementAttribute("americanExercise", typeof(AmericanExercise))]
// [System.Xml.Serialization.XmlElementAttribute("bermudaExercise", typeof(BermudaExercise))]
// [System.Xml.Serialization.XmlElementAttribute("europeanExercise", typeof(EuropeanExercise))]
// public Exercise Item {
public static void SwaptionSetEuropeanExercise(Swaption swaption, EuropeanExercise europeanExercise)
{
swaption.Item = europeanExercise;
}
public void testVega()
{
//"Testing swaption vega...";
CommonVars vars = new CommonVars();
Settlement.Type[] types = { Settlement.Type.Physical, Settlement.Type.Cash };
double[] strikes = { 0.03, 0.04, 0.05, 0.06, 0.07 };
double[] vols = { 0.01, 0.20, 0.30, 0.70, 0.90 };
double shift = 1e-8;
for (int i = 0; i < exercises.Length; i++)
{
Date exerciseDate = vars.calendar.advance(vars.today, exercises[i]);
// A VERIFIER§§§§
Date startDate = vars.calendar.advance(exerciseDate,
vars.settlementDays, TimeUnit.Days);
for (int j = 0; j < lengths.Length; j++)
{
for (int t = 0; t < strikes.Length; t++)
{
for (int h = 0; h < type.Length; h++)
{
VanillaSwap swap =
new MakeVanillaSwap(lengths[j], vars.index, strikes[t])
.withEffectiveDate(startDate)
.withFloatingLegSpread(0.0)
.withType(type[h]);
for (int u = 0; u < vols.Length; u++)
{
Swaption swaption =
vars.makeSwaption(swap, exerciseDate,
vols[u], types[h]);
// FLOATING_POINT_EXCEPTION
Swaption swaption1 =
vars.makeSwaption(swap, exerciseDate,
vols[u] - shift, types[h]);
Swaption swaption2 =
vars.makeSwaption(swap, exerciseDate,
vols[u] + shift, types[h]);
double swaptionNPV = swaption.NPV();
double numericalVegaPerPoint =
(swaption2.NPV() - swaption1.NPV()) / (200.0 * shift);
// check only relevant vega
if (numericalVegaPerPoint / swaptionNPV > 1.0e-7)
{
double analyticalVegaPerPoint =
(double)swaption.result("vega") / 100.0;
double discrepancy = Math.Abs(analyticalVegaPerPoint
- numericalVegaPerPoint);
discrepancy /= numericalVegaPerPoint;
double tolerance = 0.015;
if (discrepancy > tolerance)
{
Assert.Fail("failed to compute swaption vega:" +
"\n option tenor: " + exercises[i] +
"\n volatility: " + vols[u] +
"\n option type: " + swaption.type() +
"\n swap tenor: " + lengths[j] +
"\n strike: " + strikes[t] +
"\n settlement: " + types[h] +
"\n nominal: " + swaption.underlyingSwap().nominal +
"\n npv: " + swaptionNPV +
"\n calculated vega: " + analyticalVegaPerPoint +
"\n expected vega: " + numericalVegaPerPoint +
"\n discrepancy: " + discrepancy +
"\n tolerance: " + tolerance);
}
}
}
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="swaptionFpML"> </param>
/// <param name="basePartyReference"></param>
public InterestRateSwaptionPricer(ILogger logger, ICoreCache cache, String nameSpace,
//List<Pair<IBusinessCalendar, IBusinessCalendar>> swapCalendars,
Swaption swaptionFpML, string basePartyReference)
: this(logger, cache, nameSpace, swaptionFpML, basePartyReference, false)
{
}
public void testCachedValues()
{
//("Testing Bermudan swaption against cached values...");
CommonVars vars = new CommonVars();
vars.today = new Date(15, Month.February, 2002);
Settings.setEvaluationDate(vars.today);
vars.settlement = new Date(19, Month.February, 2002);
// flat yield term structure impling 1x5 swap at 5%
vars.termStructure.linkTo(Utilities.flatRate(vars.settlement,
0.04875825,
new Actual365Fixed()));
double atmRate = vars.makeSwap(0.0).fairRate();
VanillaSwap itmSwap = vars.makeSwap(0.8*atmRate);
VanillaSwap atmSwap = vars.makeSwap(atmRate);
VanillaSwap otmSwap = vars.makeSwap(1.2*atmRate);
double a = 0.048696, sigma = 0.0058904;
ShortRateModel model=new HullWhite(vars.termStructure,a, sigma);
List<Date> exerciseDates= new List<Date>();
List<CashFlow> leg = atmSwap.fixedLeg();
for (int i=0; i<leg.Count; i++) {
Coupon coupon = (Coupon)(leg[i]);
exerciseDates.Add(coupon.accrualStartDate());
}
Exercise exercise = new BermudanExercise(exerciseDates);
IPricingEngine engine = new TreeSwaptionEngine(model, 50);
#if QL_USE_INDEXED_COUPON
Real itmValue = 42.2413, atmValue = 12.8789, otmValue = 2.4759;
#else
double itmValue = 42.2470, atmValue = 12.8826, otmValue = 2.4769;
#endif
double tolerance = 1.0e-4;
Swaption swaption = new Swaption(itmSwap, exercise);
swaption.setPricingEngine(engine);
if (Math.Abs(swaption.NPV()-itmValue) > tolerance)
Assert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValue);
swaption = new Swaption(atmSwap, exercise);
swaption.setPricingEngine(engine);
if (Math.Abs(swaption.NPV()-atmValue) > tolerance)
Assert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValue);
swaption = new Swaption(otmSwap, exercise);
swaption.setPricingEngine(engine);
if (Math.Abs(swaption.NPV()-otmValue) > tolerance)
Assert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValue);
for (int j=0; j<exerciseDates.Count; j++)
exerciseDates[j] = vars.calendar.adjust(exerciseDates[j]-10);
exercise = new BermudanExercise(exerciseDates);
#if QL_USE_INDEXED_COUPON
itmValue = 42.1917; atmValue = 12.7788; otmValue = 2.4388;
#else
itmValue = 42.1974; atmValue = 12.7825; otmValue = 2.4399;
#endif
swaption = new Swaption(itmSwap, exercise);
swaption.setPricingEngine(engine);
if (Math.Abs(swaption.NPV()-itmValue) > tolerance)
Assert.Fail("failed to reproduce cached in-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + itmValue);
swaption = new Swaption(atmSwap, exercise);
swaption.setPricingEngine(engine);
if (Math.Abs(swaption.NPV()-atmValue) > tolerance)
Assert.Fail("failed to reproduce cached at-the-money swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + atmValue);
swaption = new Swaption(otmSwap, exercise);
swaption.setPricingEngine(engine);
if (Math.Abs(swaption.NPV()-otmValue) > tolerance)
Assert.Fail("failed to reproduce cached out-of-the-money "
+ "swaption value:\n"
+ "calculated: " + swaption.NPV() + "\n"
+ "expected: " + otmValue);
}
public void testStrikeDependency()
{
//("Testing swaption dependency on strike......");
CommonVars vars = new CommonVars();
double[] strikes = new double[] { 0.03, 0.04, 0.05, 0.06, 0.07 };
for (int i = 0; i < exercises.Length; i++)
{
for (int j = 0; j < lengths.Length; j++)
{
for (int k = 0; k < type.Length; k++)
{
Date exerciseDate = vars.calendar.advance(vars.today,
exercises[i]);
Date startDate = vars.calendar.advance(exerciseDate,
vars.settlementDays, TimeUnit.Days);
// store the results for different rates...
List <double> values = new InitializedList <double>(strikes.Length);
List <double> values_cash = new InitializedList <double>(strikes.Length);
double vol = 0.20;
for (int l = 0; l < strikes.Length; l++)
{
VanillaSwap swap = new MakeVanillaSwap(lengths[j], vars.index, strikes[l])
.withEffectiveDate(startDate)
.withFloatingLegSpread(0.0)
.withType(type[k]);
Swaption swaption = vars.makeSwaption(swap, exerciseDate, vol);
// FLOATING_POINT_EXCEPTION
values[l] = swaption.NPV();
Swaption swaption_cash = vars.makeSwaption(swap, exerciseDate, vol,
Settlement.Type.Cash);
values_cash[l] = swaption_cash.NPV();
}
// and check that they go the right way
if (type[k] == VanillaSwap.Type.Payer)
{
for (int z = 0; z < values.Count - 1; z++)
{
if (values[z] < values[z + 1])
{
Assert.Fail("NPV of Payer swaption with delivery settlement" +
"is increasing with the strike:" +
"\noption tenor: " + exercises[i] +
"\noption date: " + exerciseDate +
"\nvolatility: " + vol +
"\nswap tenor: " + lengths[j] +
"\nvalue: " + values[z] + " at strike: " + strikes[z] +
"\nvalue: " + values[z + 1] + " at strike: " + strikes[z + 1]);
}
}
for (int z = 0; z < values_cash.Count - 1; z++)
{
if (values_cash[z] < values_cash[z + 1])
{
Assert.Fail("NPV of Payer swaption with cash settlement" +
"is increasing with the strike:" +
"\noption tenor: " + exercises[i] +
"\noption date: " + exerciseDate +
"\nvolatility: " + vol +
"\nswap tenor: " + lengths[j] +
"\nvalue: " + values_cash[z] + " at strike: " + strikes[z] +
"\nvalue: " + values_cash[z + 1] + " at strike: " + strikes[z + 1]);
}
}
}
else
{
for (int z = 0; z < values.Count - 1; z++)
{
if (values[z] > values[z + 1])
{
Assert.Fail("NPV of Receiver swaption with delivery settlement" +
"is increasing with the strike:" +
"\noption tenor: " + exercises[i] +
"\noption date: " + exerciseDate +
"\nvolatility: " + vol +
"\nswap tenor: " + lengths[j] +
"\nvalue: " + values[z] + " at strike: " + strikes[z] +
"\nvalue: " + values[z + 1] + " at strike: " + strikes[z + 1]);
}
}
for (int z = 0; z < values_cash.Count - 1; z++)
{
if (values[z] > values[z + 1])
{
Assert.Fail("NPV of Receiver swaption with cash settlement" +
"is increasing with the strike:" +
"\noption tenor: " + exercises[i] +
"\noption date: " + exerciseDate +
"\nvolatility: " + vol +
"\nswap tenor: " + lengths[j] +
"\nvalue: " + values_cash[z] + " at strike: " + strikes[z] +
"\nvalue: " + values_cash[z + 1] + " at strike: " + strikes[z + 1]);
}
}
}
}
}
}
}
private static void Main()
{
DateTime startTime = DateTime.Now;
var todaysDate = new DateTime(2002, 2, 15);
Settings.instance().setEvaluationDate(todaysDate);
Calendar calendar = new TARGET();
var settlementDate = new Date(19, Month.February, 2002);
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
var myTermStructure = new FlatForward(settlementDate, new QuoteHandle(flatRate), new Actual365Fixed());
var rhTermStructure = new RelinkableYieldTermStructureHandle();
rhTermStructure.linkTo(myTermStructure);
// Define the ATM/OTM/ITM swaps
var fixedLegTenor = new Period(1, TimeUnit.Years);
const BusinessDayConvention fixedLegConvention = BusinessDayConvention.Unadjusted;
const BusinessDayConvention floatingLegConvention = BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter = new Thirty360(Thirty360.Convention.European);
var floatingLegTenor = new Period(6, TimeUnit.Months);
const 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);
var fixedSchedule = new Schedule(startDate, maturity, fixedLegTenor, calendar, fixedLegConvention, fixedLegConvention, DateGeneration.Rule.Forward, false);
var floatSchedule = new Schedule(startDate, maturity, floatingLegTenor, calendar, floatingLegConvention, floatingLegConvention, DateGeneration.Rule.Forward, false);
var swap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0, indexSixMonths.dayCounter());
var swapEngine = new DiscountingSwapEngine(rhTermStructure);
swap.setPricingEngine(swapEngine);
double fixedAtmRate = swap.fairRate();
double fixedOtmRate = fixedAtmRate * 1.2;
double fixedItmRate = fixedAtmRate * 0.8;
var atmSwap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedAtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
var otmSwap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedOtmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
var itmSwap = new VanillaSwap(VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedItmRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
atmSwap.setPricingEngine(swapEngine);
otmSwap.setPricingEngine(swapEngine);
itmSwap.setPricingEngine(swapEngine);
// defining the swaptions to be used in model calibration
var swaptionMaturities = new PeriodVector
{
new Period(1, TimeUnit.Years),
new Period(2, TimeUnit.Years),
new Period(3, TimeUnit.Years),
new Period(4, TimeUnit.Years),
new Period(5, TimeUnit.Years)
};
var swaptions = new CalibrationHelperVector();
// List of times that have to be included in the timegrid
var times = new DoubleVector();
for (int i = 0; i < NUM_ROWS; i++)
{
int j = NUM_COLS - i - 1; // 1x5, 2x4, 3x3, 4x2, 5x1
int k = i * NUM_COLS + j;
Quote vol = new SimpleQuote(SWAPTION_VOLS[k]);
var helper = new SwaptionHelper(swaptionMaturities[i], new Period(SWAP_LENGHTS[j], TimeUnit.Years),
new QuoteHandle(vol),
indexSixMonths, indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure);
swaptions.Add(helper);
times.AddRange(helper.times());
}
// Building time-grid
var grid = new TimeGrid(times, 30);
// defining the models
// G2 modelG2 = new G2(rhTermStructure));
var modelHw = new HullWhite(rhTermStructure);
var modelHw2 = new HullWhite(rhTermStructure);
var modelBk = new BlackKarasinski(rhTermStructure);
// model calibrations
Console.WriteLine("Hull-White (analytic formulae) calibration");
foreach (CalibrationHelper calibrationHelper in swaptions)
{
NQuantLibc.as_black_helper(calibrationHelper).setPricingEngine(new JamshidianSwaptionEngine(modelHw));
}
CalibrateModel(modelHw, swaptions, 0.05);
Console.WriteLine("Hull-White (numerical) calibration");
foreach (CalibrationHelper calibrationHelper in swaptions)
{
NQuantLibc.as_black_helper(calibrationHelper).setPricingEngine(new TreeSwaptionEngine(modelHw2, grid));
}
CalibrateModel(modelHw2, swaptions, 0.05);
Console.WriteLine("Black-Karasinski (numerical) calibration");
foreach (CalibrationHelper calibrationHelper in swaptions)
{
NQuantLibc.as_black_helper(calibrationHelper).setPricingEngine(new TreeSwaptionEngine(modelBk, grid));
}
CalibrateModel(modelBk, swaptions, 0.05);
// ATM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption struck at {0} (ATM)", fixedAtmRate);
var bermudanDates = new DateVector();
var schedule = new Schedule(startDate, maturity,
new Period(3, TimeUnit.Months), calendar,
BusinessDayConvention.Following,
BusinessDayConvention.Following,
DateGeneration.Rule.Forward, false);
for (uint i = 0; i < schedule.size(); i++)
{
bermudanDates.Add(schedule.date(i));
}
Exercise bermudaExercise = new BermudanExercise(bermudanDates);
var bermudanSwaption = new Swaption(atmSwap, bermudaExercise);
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw, 50));
Console.WriteLine("HW: " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelHw2, 50));
Console.WriteLine("HW (num): " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(new TreeSwaptionEngine(modelBk, 50));
Console.WriteLine("BK (num): " + bermudanSwaption.NPV());
DateTime endTime = DateTime.Now;
TimeSpan delta = endTime - startTime;
Console.WriteLine();
Console.WriteLine("Run completed in {0} s", delta.TotalSeconds);
Console.WriteLine();
}
public void testSwaptionPricing()
{
//"Testing forward swap and swaption pricing...");
//SavedSettings backup;
const int size = 10;
const int steps = 8*size;
#if QL_USE_INDEXED_COUPON
const double tolerance = 1e-6;
#else
const double tolerance = 1e-12;
#endif
List<Date> dates = new List<Date>();
List<double> rates = new List<double>();
dates.Add(new Date(4,9,2005));
dates.Add(new Date(4,9,2011));
rates.Add(0.04);
rates.Add(0.08);
IborIndex index = makeIndex(dates, rates);
LiborForwardModelProcess process = new LiborForwardModelProcess(size, index);
LmCorrelationModel corrModel = new LmExponentialCorrelationModel(size, 0.5);
LmVolatilityModel volaModel = new LmLinearExponentialVolatilityModel(process.fixingTimes(),
0.291, 1.483, 0.116, 0.00001);
// set-up pricing engine
process.setCovarParam((LfmCovarianceParameterization)
new LfmCovarianceProxy(volaModel, corrModel));
// set-up a small Monte-Carlo simulation to price swations
List<double> tmp = process.fixingTimes();
TimeGrid grid=new TimeGrid(tmp ,steps);
List<int> location=new List<int>();
for (int i=0; i < tmp.Count; ++i) {
location.Add(grid.index(tmp[i])) ;
}
ulong seed=42;
const int nrTrails = 5000;
LowDiscrepancy.icInstance = new InverseCumulativeNormal();
IRNG rsg = (InverseCumulativeRsg<RandomSequenceGenerator<MersenneTwisterUniformRng>
,InverseCumulativeNormal>)
new PseudoRandom().make_sequence_generator(process.factors()*(grid.size()-1),seed);
MultiPathGenerator<IRNG> generator=new MultiPathGenerator<IRNG>(process,
grid,
rsg, false);
LiborForwardModel liborModel = new LiborForwardModel(process, volaModel, corrModel);
Calendar calendar = index.fixingCalendar();
DayCounter dayCounter = index.forwardingTermStructure().link.dayCounter();
BusinessDayConvention convention = index.businessDayConvention();
Date settlement = index.forwardingTermStructure().link.referenceDate();
SwaptionVolatilityMatrix m = liborModel.getSwaptionVolatilityMatrix();
for (int i=1; i < size; ++i) {
for (int j=1; j <= size-i; ++j) {
Date fwdStart = settlement + new Period(6*i, TimeUnit.Months);
Date fwdMaturity = fwdStart + new Period(6*j, TimeUnit.Months);
Schedule schedule =new Schedule(fwdStart, fwdMaturity, index.tenor(), calendar,
convention, convention, DateGeneration.Rule.Forward, false);
double swapRate = 0.0404;
VanillaSwap forwardSwap = new VanillaSwap(VanillaSwap.Type.Receiver, 1.0,
schedule, swapRate, dayCounter,
schedule, index, 0.0, index.dayCounter());
forwardSwap.setPricingEngine(new DiscountingSwapEngine(index.forwardingTermStructure()));
// check forward pricing first
double expected = forwardSwap.fairRate();
double calculated = liborModel.S_0(i-1,i+j-1);
if (Math.Abs(expected - calculated) > tolerance)
Assert.Fail("Failed to reproduce fair forward swap rate"
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
swapRate = forwardSwap.fairRate();
forwardSwap =
new VanillaSwap(VanillaSwap.Type.Receiver, 1.0,
schedule, swapRate, dayCounter,
schedule, index, 0.0, index.dayCounter());
forwardSwap.setPricingEngine(new DiscountingSwapEngine(index.forwardingTermStructure()));
if (i == j && i<=size/2) {
IPricingEngine engine =
new LfmSwaptionEngine(liborModel, index.forwardingTermStructure());
Exercise exercise =
new EuropeanExercise(process.fixingDates()[i]);
Swaption swaption =
new Swaption(forwardSwap, exercise);
swaption.setPricingEngine(engine);
GeneralStatistics stat = new GeneralStatistics();
for (int n=0; n<nrTrails; ++n) {
Sample<MultiPath> path = (n%2!=0) ? generator.antithetic()
: generator.next();
//Sample<MultiPath> path = generator.next();
List<double> rates_ = new InitializedList<double>(size);
for (int k=0; k<process.size(); ++k) {
rates_[k] = path.value[k][location[i]];
}
List<double> dis = process.discountBond(rates_);
double npv=0.0;
for (int k=i; k < i+j; ++k) {
npv += (swapRate - rates_[k])
* ( process.accrualEndTimes()[k]
- process.accrualStartTimes()[k])*dis[k];
}
stat.add(Math.Max(npv, 0.0));
}
if (Math.Abs(swaption.NPV() - stat.mean())
> stat.errorEstimate()*2.35)
Assert.Fail("Failed to reproduce swaption npv"
+ "\n calculated: " + stat.mean()
+ "\n expected: " + swaption.NPV());
}
}
}
}
public virtual void test_physicalSettlement()
{
Swaption swaption = Swaption.builder().swaptionSettlement(PhysicalSwaptionSettlement.DEFAULT).expiryDate(AdjustableDate.of(SWAPTION_EXERCISE_DATE)).expiryTime(SWAPTION_EXPIRY_TIME).expiryZone(SWAPTION_EXPIRY_ZONE).longShort(LongShort.LONG).underlying(SWAP_REC).build();
assertThrowsIllegalArg(() => PRICER_SWAPTION.presentValue(swaption.resolve(REF_DATA), RATE_PROVIDER, VOLS));
}
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();
}
static void Main(string[] args)
{
DateTime startTime = DateTime.Now;
Date todaysDate = new Date(15, Month.February, 2002);
Calendar calendar = new TARGET();
Date settlementDate = new Date(19, Month.February, 2002);
Settings.instance().setEvaluationDate(todaysDate);
// flat yield term structure impling 1x5 swap at 5%
Quote flatRate = new SimpleQuote(0.04875825);
FlatForward myTermStructure = new FlatForward(
settlementDate,
new QuoteHandle(flatRate),
new Actual365Fixed());
RelinkableYieldTermStructureHandle rhTermStructure =
new RelinkableYieldTermStructureHandle();
rhTermStructure.linkTo(myTermStructure);
// Define the ATM/OTM/ITM swaps
Period fixedLegTenor = new Period(1, TimeUnit.Years);
BusinessDayConvention fixedLegConvention =
BusinessDayConvention.Unadjusted;
BusinessDayConvention floatingLegConvention =
BusinessDayConvention.ModifiedFollowing;
DayCounter fixedLegDayCounter =
new Thirty360(Thirty360.Convention.European);
Period floatingLegTenor = new Period(6, TimeUnit.Months);
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,
fixedLegTenor, calendar, fixedLegConvention, fixedLegConvention,
DateGeneration.Rule.Forward, false);
Schedule floatSchedule = new Schedule(startDate, maturity,
floatingLegTenor, calendar, floatingLegConvention,
floatingLegConvention, DateGeneration.Rule.Forward, false);
VanillaSwap swap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, dummyFixedRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
DiscountingSwapEngine swapEngine =
new DiscountingSwapEngine(rhTermStructure);
swap.setPricingEngine(swapEngine);
double fixedATMRate = swap.fairRate();
double fixedOTMRate = fixedATMRate * 1.2;
double fixedITMRate = fixedATMRate * 0.8;
VanillaSwap atmSwap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedATMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap otmSwap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedOTMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
VanillaSwap itmSwap = new VanillaSwap(
VanillaSwap.Type.Payer, 1000.0,
fixedSchedule, fixedITMRate, fixedLegDayCounter,
floatSchedule, indexSixMonths, 0.0,
indexSixMonths.dayCounter());
atmSwap.setPricingEngine(swapEngine);
otmSwap.setPricingEngine(swapEngine);
itmSwap.setPricingEngine(swapEngine);
// defining the swaptions to be used in model calibration
PeriodVector swaptionMaturities = new PeriodVector();
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));
CalibrationHelperVector swaptions = new CalibrationHelperVector();
// List of times that have to be included in the timegrid
DoubleVector times = new DoubleVector();
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]);
SwaptionHelper helper = new SwaptionHelper(
swaptionMaturities[i],
new Period(swapLengths[j], TimeUnit.Years),
new QuoteHandle(vol),
indexSixMonths,
indexSixMonths.tenor(),
indexSixMonths.dayCounter(),
indexSixMonths.dayCounter(),
rhTermStructure);
swaptions.Add(helper);
times.AddRange(helper.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++)
// NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
// new G2SwaptionEngine( modelG2, 6.0, 16 ) );
//
// calibrateModel( modelG2, swaptions, 0.05);
// Console.WriteLine( "calibrated to:" );
// Console.WriteLine( "a = " + modelG2.parameters()[0] );
// Console.WriteLine( "sigma = " + modelG2.parameters()[1] );
// Console.WriteLine( "b = " + modelG2.parameters()[2] );
// Console.WriteLine( "eta = " + modelG2.parameters()[3] );
// Console.WriteLine( "rho = " + modelG2.parameters()[4] );
Console.WriteLine("Hull-White (analytic formulae) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
new JamshidianSwaptionEngine(modelHW));
}
calibrateModel(modelHW, swaptions, 0.05);
// Console.WriteLine( "calibrated to:" );
// Console.WriteLine( "a = " + modelHW.parameters()[0] );
// Console.WriteLine( "sigma = " + modelHW.parameters()[1] );
Console.WriteLine("Hull-White (numerical) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
new TreeSwaptionEngine(modelHW2, grid));
}
calibrateModel(modelHW2, swaptions, 0.05);
// std::cout << "calibrated to:\n"
// << "a = " << modelHW2->params()[0] << ", "
// << "sigma = " << modelHW2->params()[1]
// << std::endl << std::endl;
Console.WriteLine("Black-Karasinski (numerical) calibration");
for (int i = 0; i < swaptions.Count; i++)
{
NQuantLibc.as_black_helper(swaptions[i]).setPricingEngine(
new TreeSwaptionEngine(modelBK, grid));
}
calibrateModel(modelBK, swaptions, 0.05);
// std::cout << "calibrated to:\n"
// << "a = " << modelBK->params()[0] << ", "
// << "sigma = " << modelBK->params()[1]
// << std::endl << std::endl;
// ATM Bermudan swaption pricing
Console.WriteLine("Payer bermudan swaption struck at {0} (ATM)",
fixedATMRate);
DateVector bermudanDates = new DateVector();
Schedule schedule = new Schedule(startDate, maturity,
new Period(3, TimeUnit.Months), calendar,
BusinessDayConvention.Following,
BusinessDayConvention.Following,
DateGeneration.Rule.Forward, false);
for (uint i = 0; i < schedule.size(); i++)
{
bermudanDates.Add(schedule.date(i));
}
Exercise bermudaExercise = new BermudanExercise(bermudanDates);
Swaption bermudanSwaption =
new Swaption(atmSwap, bermudaExercise);
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelHW, 50));
Console.WriteLine("HW: " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelHW2, 50));
Console.WriteLine("HW (num): " + bermudanSwaption.NPV());
bermudanSwaption.setPricingEngine(
new TreeSwaptionEngine(modelBK, 50));
Console.WriteLine("BK (num): " + bermudanSwaption.NPV());
DateTime endTime = DateTime.Now;
TimeSpan delta = endTime - startTime;
Console.WriteLine();
Console.WriteLine("Run completed in {0} s", delta.TotalSeconds);
Console.WriteLine();
}
public virtual void test_physicalSettlement()
{
Swaption swaption = Swaption.builder().expiryDate(AdjustableDate.of(MATURITY, BDA_MF)).expiryTime(LocalTime.NOON).expiryZone(ZoneOffset.UTC).swaptionSettlement(PhysicalSwaptionSettlement.DEFAULT).longShort(LONG).underlying(SWAP_PAY).build();
assertThrowsIllegalArg(() => PRICER.impliedVolatility(swaption.resolve(REF_DATA), RATE_PROVIDER, VOLS));
}
public void testSwaptionPricing()
{
// Testing forward swap and swaption pricing
const int size = 10;
const int steps = 8 * size;
#if QL_USE_INDEXED_COUPON
const double tolerance = 1e-6;
#else
const double tolerance = 1e-12;
#endif
List <Date> dates = new List <Date>();
List <double> rates = new List <double>();
dates.Add(new Date(4, 9, 2005));
dates.Add(new Date(4, 9, 2011));
rates.Add(0.04);
rates.Add(0.08);
IborIndex index = makeIndex(dates, rates);
LiborForwardModelProcess process = new LiborForwardModelProcess(size, index);
LmCorrelationModel corrModel = new LmExponentialCorrelationModel(size, 0.5);
LmVolatilityModel volaModel = new LmLinearExponentialVolatilityModel(process.fixingTimes(),
0.291, 1.483, 0.116, 0.00001);
// set-up pricing engine
process.setCovarParam((LfmCovarianceParameterization)
new LfmCovarianceProxy(volaModel, corrModel));
// set-up a small Monte-Carlo simulation to price swations
List <double> tmp = process.fixingTimes();
TimeGrid grid = new TimeGrid(tmp, tmp.Count, steps);
List <int> location = new List <int>();
for (int i = 0; i < tmp.Count; ++i)
{
location.Add(grid.index(tmp[i]));
}
ulong seed = 42;
const int nrTrails = 5000;
LowDiscrepancy.icInstance = new InverseCumulativeNormal();
IRNG rsg = (InverseCumulativeRsg <RandomSequenceGenerator <MersenneTwisterUniformRng>
, InverseCumulativeNormal>)
new PseudoRandom().make_sequence_generator(process.factors() * (grid.size() - 1), seed);
MultiPathGenerator <IRNG> generator = new MultiPathGenerator <IRNG>(process,
grid,
rsg, false);
LiborForwardModel liborModel = new LiborForwardModel(process, volaModel, corrModel);
Calendar calendar = index.fixingCalendar();
DayCounter dayCounter = index.forwardingTermStructure().link.dayCounter();
BusinessDayConvention convention = index.businessDayConvention();
Date settlement = index.forwardingTermStructure().link.referenceDate();
SwaptionVolatilityMatrix m = liborModel.getSwaptionVolatilityMatrix();
for (int i = 1; i < size; ++i)
{
for (int j = 1; j <= size - i; ++j)
{
Date fwdStart = settlement + new Period(6 * i, TimeUnit.Months);
Date fwdMaturity = fwdStart + new Period(6 * j, TimeUnit.Months);
Schedule schedule = new Schedule(fwdStart, fwdMaturity, index.tenor(), calendar,
convention, convention, DateGeneration.Rule.Forward, false);
double swapRate = 0.0404;
VanillaSwap forwardSwap = new VanillaSwap(VanillaSwap.Type.Receiver, 1.0,
schedule, swapRate, dayCounter,
schedule, index, 0.0, index.dayCounter());
forwardSwap.setPricingEngine(new DiscountingSwapEngine(index.forwardingTermStructure()));
// check forward pricing first
double expected = forwardSwap.fairRate();
double calculated = liborModel.S_0(i - 1, i + j - 1);
if (Math.Abs(expected - calculated) > tolerance)
{
QAssert.Fail("Failed to reproduce fair forward swap rate"
+ "\n calculated: " + calculated
+ "\n expected: " + expected);
}
swapRate = forwardSwap.fairRate();
forwardSwap =
new VanillaSwap(VanillaSwap.Type.Receiver, 1.0,
schedule, swapRate, dayCounter,
schedule, index, 0.0, index.dayCounter());
forwardSwap.setPricingEngine(new DiscountingSwapEngine(index.forwardingTermStructure()));
if (i == j && i <= size / 2)
{
IPricingEngine engine =
new LfmSwaptionEngine(liborModel, index.forwardingTermStructure());
Exercise exercise =
new EuropeanExercise(process.fixingDates()[i]);
Swaption swaption =
new Swaption(forwardSwap, exercise);
swaption.setPricingEngine(engine);
GeneralStatistics stat = new GeneralStatistics();
for (int n = 0; n < nrTrails; ++n)
{
Sample <IPath> path = (n % 2 != 0) ? generator.antithetic()
: generator.next();
MultiPath value = path.value as MultiPath;
Utils.QL_REQUIRE(value != null, () => "Invalid Path");
//Sample<MultiPath> path = generator.next();
List <double> rates_ = new InitializedList <double>(size);
for (int k = 0; k < process.size(); ++k)
{
rates_[k] = value[k][location[i]];
}
List <double> dis = process.discountBond(rates_);
double npv = 0.0;
for (int k = i; k < i + j; ++k)
{
npv += (swapRate - rates_[k])
* (process.accrualEndTimes()[k]
- process.accrualStartTimes()[k]) * dis[k];
}
stat.add(Math.Max(npv, 0.0));
}
if (Math.Abs(swaption.NPV() - stat.mean())
> stat.errorEstimate() * 2.35)
{
QAssert.Fail("Failed to reproduce swaption npv"
+ "\n calculated: " + stat.mean()
+ "\n expected: " + swaption.NPV());
}
}
}
}
}
public double swaption(Swaption.Arguments arguments,
double fixedRate,
double range,
int intervals)
{
Date settlement = termStructure().link.referenceDate();
DayCounter dayCounter = termStructure().link.dayCounter();
double start = dayCounter.yearFraction(settlement,
arguments.floatingResetDates[0]);
double w = (arguments.type==VanillaSwap.Type.Payer ? 1 : -1 );
List<double> fixedPayTimes = new InitializedList<double>(arguments.fixedPayDates.Count);
for (int i=0; i<fixedPayTimes.Count; ++i)
fixedPayTimes[i] =
dayCounter.yearFraction(settlement,
arguments.fixedPayDates[i]);
SwaptionPricingFunction function = new SwaptionPricingFunction(a(),
sigma(), b(), eta(), rho(),
w, start,
fixedPayTimes,
fixedRate,this);
double upper = function.mux() + range*function.sigmax();
double lower = function.mux() - range*function.sigmax();
SegmentIntegral integrator = new SegmentIntegral(intervals);
return arguments.nominal*w*termStructure().link.discount(start)*
integrator.value(function.value, lower, upper);
}