public MakeCms(Period swapTenor,
SwapIndex swapIndex,
IborIndex iborIndex,
double iborSpread = 0.0,
Period forwardStart = null,
Date maturityDate = null)
{
swapTenor_ = swapTenor;
swapIndex_ = swapIndex;
iborIndex_ = iborIndex;
iborSpread_ = iborSpread;
iborCap_ = null;
iborFloor_ = null;
useAtmSpread_ = false;
forwardStart_ = forwardStart ?? new Period(0, TimeUnit.Days);
cmsSpread_ = 0.0;
cmsGearing_ = 1.0;
cmsCap_ = null;
cmsFloor_ = null;
effectiveDate_ = null;
cmsCalendar_ = swapIndex.fixingCalendar();
floatCalendar_ = iborIndex.fixingCalendar();
payCms_ = true;
nominal_ = 1.0;
maturityDate_ = maturityDate;
cmsTenor_ = new Period(3, TimeUnit.Months);
floatTenor_ = iborIndex.tenor();
cmsConvention_ = BusinessDayConvention.ModifiedFollowing;
cmsTerminationDateConvention_ = BusinessDayConvention.ModifiedFollowing;
floatConvention_ = iborIndex.businessDayConvention();
floatTerminationDateConvention_ = iborIndex.businessDayConvention();
cmsRule_ = DateGeneration.Rule.Backward;
floatRule_ = DateGeneration.Rule.Backward;
cmsEndOfMonth_ = false;
floatEndOfMonth_ = false;
cmsFirstDate_ = null;
cmsNextToLastDate_ = null;
floatFirstDate_ = null;
floatNextToLastDate_ = null;
cmsDayCount_ = new Actual360();
floatDayCount_ = iborIndex.dayCounter();
engine_ = new DiscountingSwapEngine(swapIndex.forwardingTermStructure());
}
public override void calculate()
{
Utils.QL_REQUIRE(arguments_.settlementMethod != Settlement.Method.ParYieldCurve, () =>
"cash-settled (ParYieldCurve) swaptions not priced with Lfm engine");
VanillaSwap swap = arguments_.swap;
IPricingEngine pe = new DiscountingSwapEngine(discountCurve_);
swap.setPricingEngine(pe);
double correction = swap.spread *
Math.Abs(swap.floatingLegBPS() / swap.fixedLegBPS());
double fixedRate = swap.fixedRate - correction;
double fairRate = swap.fairRate() - correction;
SwaptionVolatilityMatrix volatility =
model_.link.getSwaptionVolatilityMatrix();
Date referenceDate = volatility.referenceDate();
DayCounter dayCounter = volatility.dayCounter();
double exercise = dayCounter.yearFraction(referenceDate,
arguments_.exercise.date(0));
double swapLength =
dayCounter.yearFraction(referenceDate,
arguments_.fixedPayDates.Last())
- dayCounter.yearFraction(referenceDate,
arguments_.fixedResetDates[0]);
Option.Type w = arguments_.type == VanillaSwap.Type.Payer ?
Option.Type.Call : Option.Type.Put;
double vol = volatility.volatility(exercise, swapLength,
fairRate, true);
results_.value = (swap.fixedLegBPS() / Const.BASIS_POINT) *
Utils.blackFormula(w, fixedRate, fairRate, vol * Math.Sqrt(exercise));
}
public MakeCms withDiscountingTermStructure(Handle <YieldTermStructure> discountingTermStructure)
{
engine_ = new DiscountingSwapEngine(discountingTermStructure);
return(this);
}
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();
}
public OvernightIndexedSwap value()
{
Date startDate;
if (effectiveDate_ != null)
{
startDate = effectiveDate_;
}
else
{
Date refDate = Settings.Instance.evaluationDate();
// if the evaluation date is not a business day
// then move to the next business day
refDate = calendar_.adjust(refDate);
Date spotDate = calendar_.advance(refDate, new Period(settlementDays_, TimeUnit.Days));
startDate = spotDate + forwardStart_;
if (forwardStart_.length() < 0)
{
startDate = calendar_.adjust(startDate, BusinessDayConvention.Preceding);
}
else
{
startDate = calendar_.adjust(startDate, BusinessDayConvention.Following);
}
}
// OIS end of month default
bool usedEndOfMonth =
isDefaultEOM_ ? calendar_.isEndOfMonth(startDate) : endOfMonth_;
Date endDate = terminationDate_;
if (endDate == null)
{
if (usedEndOfMonth)
{
endDate = calendar_.advance(startDate,
swapTenor_,
BusinessDayConvention.ModifiedFollowing,
usedEndOfMonth);
}
else
{
endDate = startDate + swapTenor_;
}
}
Schedule schedule = new Schedule(startDate, endDate,
new Period(paymentFrequency_),
calendar_,
BusinessDayConvention.ModifiedFollowing,
BusinessDayConvention.ModifiedFollowing,
rule_,
usedEndOfMonth);
double?usedFixedRate = fixedRate_;
if (fixedRate_ == null)
{
OvernightIndexedSwap temp = new OvernightIndexedSwap(type_, nominal_,
schedule,
0.0, // fixed rate
fixedDayCount_,
overnightIndex_, overnightSpread_);
if (engine_ == null)
{
Handle <YieldTermStructure> disc = overnightIndex_.forwardingTermStructure();
Utils.QL_REQUIRE(!disc.empty(), () => "null term structure set to this instance of " +
overnightIndex_.name());
bool includeSettlementDateFlows = false;
IPricingEngine engine = new DiscountingSwapEngine(disc, includeSettlementDateFlows);
temp.setPricingEngine(engine);
}
else
{
temp.setPricingEngine(engine_);
}
usedFixedRate = temp.fairRate();
}
OvernightIndexedSwap ois = new OvernightIndexedSwap(type_, nominal_,
schedule,
usedFixedRate.Value, fixedDayCount_,
overnightIndex_, overnightSpread_);
if (engine_ == null)
{
Handle <YieldTermStructure> disc = overnightIndex_.forwardingTermStructure();
bool includeSettlementDateFlows = false;
IPricingEngine engine = new DiscountingSwapEngine(disc, includeSettlementDateFlows);
ois.setPricingEngine(engine);
}
else
{
ois.setPricingEngine(engine_);
}
return(ois);
}
