// Handle<YieldTermStructure> discountCurve = Handle<YieldTermStructure>());
public ForwardRateAgreement(Date valueDate, Date maturityDate, Position.Type type, double strikeForwardRate,
double notionalAmount, IborIndex index, Handle<YieldTermStructure> discountCurve)
: base(index.dayCounter(), index.fixingCalendar(), index.businessDayConvention(), index.fixingDays(), new Payoff(),
valueDate, maturityDate, discountCurve) {
fraType_ = type;
notionalAmount_ = notionalAmount;
index_ = index;
if (notionalAmount <= 0.0)
throw new ApplicationException("notional Amount must be positive");
// do I adjust this ?
// valueDate_ = calendar_.adjust(valueDate_,businessDayConvention_);
Date fixingDate = calendar_.advance(valueDate_, -settlementDays_, TimeUnit.Days);
forwardRate_ = new InterestRate(index.fixing(fixingDate), index.dayCounter(), Compounding.Simple, Frequency.Once);
strikeForwardRate_ = new InterestRate(strikeForwardRate, index.dayCounter(), Compounding.Simple, Frequency.Once);
double strike = notionalAmount_ * strikeForwardRate_.compoundFactor(valueDate_, maturityDate_);
payoff_ = new ForwardTypePayoff(fraType_, strike);
// incomeDiscountCurve_ is irrelevant to an FRA
incomeDiscountCurve_ = discountCurve_;
// income is irrelevant to FRA - set it to zero
underlyingIncome_ = 0.0;
index_.registerWith(update);
}
public VanillaSwap value()
{
Date startDate;
if (effectiveDate_ != null)
{
startDate = effectiveDate_;
}
else
{
int fixingDays = iborIndex_.fixingDays();
Date referenceDate = Settings.evaluationDate();
Date spotDate = floatCalendar_.advance(referenceDate, new Period(fixingDays, TimeUnit.Days));
startDate = spotDate + forwardStart_;
}
Date endDate;
if (terminationDate_ != null)
{
endDate = terminationDate_;
}
else
{
endDate = startDate + swapTenor_;
}
Schedule fixedSchedule = new Schedule(startDate, endDate,
fixedTenor_, fixedCalendar_,
fixedConvention_, fixedTerminationDateConvention_,
fixedRule_, fixedEndOfMonth_,
fixedFirstDate_, fixedNextToLastDate_);
Schedule floatSchedule = new Schedule(startDate, endDate,
floatTenor_, floatCalendar_,
floatConvention_, floatTerminationDateConvention_,
floatRule_, floatEndOfMonth_,
floatFirstDate_, floatNextToLastDate_);
double?usedFixedRate = fixedRate_;
if (fixedRate_ == null) // calculate a fair fixed rate if no fixed rate is provided
{
if (iborIndex_.forwardingTermStructure().empty())
{
throw new ArgumentException("no forecasting term structure set to " + iborIndex_.name());
}
VanillaSwap temp = new VanillaSwap(type_, nominal_, fixedSchedule, 0.0, fixedDayCount_,
floatSchedule, iborIndex_, floatSpread_, floatDayCount_);
temp.setPricingEngine(new DiscountingSwapEngine(iborIndex_.forwardingTermStructure()));
usedFixedRate = temp.fairRate();
}
VanillaSwap swap = new VanillaSwap(type_, nominal_, fixedSchedule, usedFixedRate.Value, fixedDayCount_,
floatSchedule, iborIndex_, floatSpread_, floatDayCount_);
swap.setPricingEngine(engine_);
return(swap);
}
public DepositRateHelper(double rate, IborIndex i)
: base(rate)
{
iborIndex_ = new IborIndex("no-fix", // never take fixing into account
i.tenor(), i.fixingDays(), new Currency(),
i.fixingCalendar(), i.businessDayConvention(),
i.endOfMonth(), i.dayCounter(), termStructureHandle_);
initializeDates();
}
public DepositRateHelper(double rate, IborIndex i)
: base(rate)
{
iborIndex_ = new IborIndex("no-fix", // never take fixing into account
i.tenor(), i.fixingDays(), new Currency(),
i.fixingCalendar(), i.businessDayConvention(),
i.endOfMonth(), i.dayCounter(), termStructureHandle_);
initializeDates();
}
protected override void initializeDates()
{
// why not using index_->fixingDays instead of settlementDays_
Date settlement = iborIndex_.fixingCalendar().advance(evaluationDate_, iborIndex_.fixingDays(), TimeUnit.Days);
earliestDate_ = iborIndex_.fixingCalendar().advance(settlement, periodToStart_,
iborIndex_.businessDayConvention(), iborIndex_.endOfMonth());
latestDate_ = iborIndex_.maturityDate(earliestDate_);
fixingDate_ = iborIndex_.fixingDate(earliestDate_);
}
public FraRateHelper(double rate, int monthsToStart, IborIndex i) : base(rate)
{
periodToStart_ = new Period(monthsToStart, TimeUnit.Months);
iborIndex_ = new IborIndex("no-fix", // never take fixing into account
i.tenor(), i.fixingDays(), new Currency(),
i.fixingCalendar(), i.businessDayConvention(),
i.endOfMonth(), i.dayCounter(), termStructureHandle_);
initializeDates();
}
public FRARateHelper(double rate, int monthsToStart, IborIndex i)
: base(rate)
{
periodToStart_ = new Period(monthsToStart, TimeUnit.Months);
iborIndex_ = new IborIndex("no-fix", // never take fixing into account
i.tenor(), i.fixingDays(), new Currency(),
i.fixingCalendar(), i.businessDayConvention(),
i.endOfMonth(), i.dayCounter(), termStructureHandle_);
initializeDates();
}
public BMASwap(Type type, double nominal,
// Libor leg
Schedule liborSchedule, double liborFraction, double liborSpread, IborIndex liborIndex, DayCounter liborDayCount,
// BMA leg
Schedule bmaSchedule, BMAIndex bmaIndex, DayCounter bmaDayCount)
: base(2)
{
type_ = type;
nominal_ = nominal;
liborFraction_ = liborFraction;
liborSpread_ = liborSpread;
BusinessDayConvention convention = liborSchedule.businessDayConvention();
legs_[0] = new IborLeg(liborSchedule, liborIndex)
.withPaymentDayCounter(liborDayCount)
.withFixingDays(liborIndex.fixingDays())
.withGearings(liborFraction)
.withSpreads(liborSpread)
.withNotionals(nominal)
.withPaymentAdjustment(convention);
legs_[1] = new AverageBMALeg(bmaSchedule, bmaIndex)
.withPaymentDayCounter(bmaDayCount)
.withNotionals(nominal)
.withPaymentAdjustment(bmaSchedule.businessDayConvention());
for (int j = 0; j < 2; ++j)
{
for (int i = 0; i < legs_[j].Count; i++)
{
legs_[j][i].registerWith(update);
}
}
switch (type_)
{
case Type.Payer:
payer_[0] = +1.0;
payer_[1] = -1.0;
break;
case Type.Receiver:
payer_[0] = -1.0;
payer_[1] = +1.0;
break;
default:
Utils.QL_FAIL("Unknown BMA-swap type");
break;
}
}
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 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 BasisSwap value()
{
Date startDate;
if (effectiveDate_ != null)
{
startDate = effectiveDate_;
}
else
{
int fixingDays = iborIndex1_.fixingDays();
Date referenceDate = Settings.evaluationDate();
Date spotDate = float1Calendar_.advance(referenceDate, new Period(fixingDays, TimeUnit.Days));
startDate = spotDate + forwardStart_;
}
Date endDate;
if (terminationDate_ != null)
{
endDate = terminationDate_;
}
else
{
endDate = startDate + swapTenor_;
}
Schedule float1Schedule = new Schedule(startDate, endDate,
float1Tenor_, float1Calendar_,
float1Convention_, float1TerminationDateConvention_,
float1Rule_, float1EndOfMonth_,
float1FirstDate_, float1NextToLastDate_);
Schedule float2Schedule = new Schedule(startDate, endDate,
float2Tenor_, float2Calendar_,
float2Convention_, float2TerminationDateConvention_,
float2Rule_, float2EndOfMonth_,
float2FirstDate_, float2NextToLastDate_);
BasisSwap swap = new BasisSwap(type_, nominal_,
float1Schedule, iborIndex1_, float1Spread_, float1DayCount_,
float2Schedule, iborIndex2_, float2Spread_, float2DayCount_);
swap.setPricingEngine(engine_);
return(swap);
}
public BMASwap(Type type, double nominal,
// Libor leg
Schedule liborSchedule, double liborFraction, double liborSpread, IborIndex liborIndex, DayCounter liborDayCount,
// BMA leg
Schedule bmaSchedule, BMAIndex bmaIndex, DayCounter bmaDayCount)
: base(2)
{
type_ = type;
nominal_ = nominal;
liborFraction_ = liborFraction;
liborSpread_ = liborSpread;
BusinessDayConvention convention = liborSchedule.businessDayConvention();
legs_[0] = new IborLeg(liborSchedule, liborIndex)
.withPaymentDayCounter(liborDayCount)
.withFixingDays(liborIndex.fixingDays())
.withGearings(liborFraction)
.withSpreads(liborSpread)
.withNotionals(nominal)
.withPaymentAdjustment(convention);
legs_[1] = new AverageBMALeg(bmaSchedule, bmaIndex)
.withPaymentDayCounter(bmaDayCount)
.withNotionals(nominal)
.withPaymentAdjustment(bmaSchedule.businessDayConvention());
for (int j=0; j<2; ++j) {
for (int i=0; i<legs_[j].Count; i++)
legs_[j][i].registerWith(update);
}
switch (type_) {
case Type.Payer:
payer_[0] = +1.0;
payer_[1] = -1.0;
break;
case Type.Receiver:
payer_[0] = -1.0;
payer_[1] = +1.0;
break;
default:
throw new ApplicationException("Unknown BMA-swap type");
}
}
public List <CashFlow> cashFlows(double amount)
{
Date refDate = index_.forwardingTermStructure().link.referenceDate();
Schedule schedule = new Schedule(refDate,
refDate + new Period(index_.tenor().length() * size_,
index_.tenor().units()),
index_.tenor(), index_.fixingCalendar(),
index_.businessDayConvention(),
index_.businessDayConvention(),
DateGeneration.Rule.Forward, false);
IborLeg cashflows = (IborLeg) new IborLeg(schedule, index_)
.withFixingDays(index_.fixingDays())
.withPaymentDayCounter(index_.dayCounter())
.withNotionals(amount)
.withPaymentAdjustment(index_.businessDayConvention());
return(cashflows.value());
}
public MakeVanillaSwap(Period swapTenor, IborIndex index, double?fixedRate = null, Period forwardStart = null)
{
swapTenor_ = swapTenor;
iborIndex_ = index;
fixedRate_ = fixedRate;
forwardStart_ = forwardStart ?? new Period(0, TimeUnit.Days);
settlementDays_ = iborIndex_.fixingDays();
fixedCalendar_ = floatCalendar_ = index.fixingCalendar();
type_ = VanillaSwap.Type.Payer;
nominal_ = 1.0;
//fixedTenor_ = new Period(1, TimeUnit.Years);
floatTenor_ = index.tenor();
fixedConvention_ = fixedTerminationDateConvention_ = BusinessDayConvention.ModifiedFollowing;
floatConvention_ = floatTerminationDateConvention_ = index.businessDayConvention();
fixedRule_ = floatRule_ = DateGeneration.Rule.Backward;
fixedEndOfMonth_ = floatEndOfMonth_ = false;
fixedFirstDate_ = fixedNextToLastDate_ = floatFirstDate_ = floatNextToLastDate_ = null;
floatSpread_ = 0.0;
//fixedDayCount_ = new Thirty360(Thirty360.Thirty360Convention.BondBasis);
floatDayCount_ = index.dayCounter();
//engine_ = new DiscountingSwapEngine(index.forwardingTermStructure());
}
// Handle<YieldTermStructure> discountCurve = Handle<YieldTermStructure>());
public ForwardRateAgreement(Date valueDate, Date maturityDate, Position.Type type, double strikeForwardRate,
double notionalAmount, IborIndex index, Handle <YieldTermStructure> discountCurve)
: base(index.dayCounter(), index.fixingCalendar(), index.businessDayConvention(), index.fixingDays(), new Payoff(),
valueDate, maturityDate, discountCurve)
{
fraType_ = type;
notionalAmount_ = notionalAmount;
index_ = index;
if (notionalAmount <= 0.0)
{
throw new ApplicationException("notional Amount must be positive");
}
// do I adjust this ?
// valueDate_ = calendar_.adjust(valueDate_,businessDayConvention_);
Date fixingDate = calendar_.advance(valueDate_, -settlementDays_, TimeUnit.Days);
forwardRate_ = new InterestRate(index.fixing(fixingDate), index.dayCounter(), Compounding.Simple, Frequency.Once);
strikeForwardRate_ = new InterestRate(strikeForwardRate, index.dayCounter(), Compounding.Simple, Frequency.Once);
double strike = notionalAmount_ * strikeForwardRate_.compoundFactor(valueDate_, maturityDate_);
payoff_ = new ForwardTypePayoff(fraType_, strike);
// incomeDiscountCurve_ is irrelevant to an FRA
incomeDiscountCurve_ = discountCurve_;
// income is irrelevant to FRA - set it to zero
underlyingIncome_ = 0.0;
index_.registerWith(update);
}
protected override void initializeDates()
{
earliestDate_ = iborIndex_.fixingCalendar().advance(evaluationDate_, iborIndex_.fixingDays(), TimeUnit.Days);
latestDate_ = iborIndex_.maturityDate(earliestDate_);
fixingDate_ = iborIndex_.fixingCalendar().advance(earliestDate_, -iborIndex_.fixingDays(), TimeUnit.Days);
}
public CapHelper(Period length,
Handle<Quote> volatility,
IborIndex index,
// data for ATM swap-rate calculation
Frequency fixedLegFrequency,
DayCounter fixedLegDayCounter,
bool includeFirstSwaplet,
Handle<YieldTermStructure> termStructure,
bool calibrateVolatility /*= false*/)
: base(volatility, termStructure, calibrateVolatility)
{
Period indexTenor = index.tenor();
double fixedRate = 0.04; // dummy value
Date startDate, maturity;
if (includeFirstSwaplet) {
startDate = termStructure.link.referenceDate();
maturity = termStructure.link.referenceDate() + length;
} else {
startDate = termStructure.link.referenceDate() + indexTenor;
maturity = termStructure.link.referenceDate() + length;
}
IborIndex dummyIndex=new
IborIndex("dummy",
indexTenor,
index.fixingDays(),
index.currency(),
index.fixingCalendar(),
index.businessDayConvention(),
index.endOfMonth(),
termStructure.link.dayCounter(),
termStructure);
List<double> nominals = new InitializedList<double>(1,1.0);
Schedule floatSchedule=new Schedule(startDate, maturity,
index.tenor(), index.fixingCalendar(),
index.businessDayConvention(),
index.businessDayConvention(),
DateGeneration.Rule.Forward, false);
List<CashFlow> floatingLeg;
IborLeg iborLeg = (IborLeg) new IborLeg(floatSchedule, index)
.withFixingDays(0)
.withNotionals(nominals)
.withPaymentAdjustment(index.businessDayConvention());
floatingLeg = iborLeg.value();
Schedule fixedSchedule=new Schedule(startDate, maturity, new Period(fixedLegFrequency),
index.fixingCalendar(),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
DateGeneration.Rule.Forward, false);
List<CashFlow> fixedLeg = new FixedRateLeg(fixedSchedule)
.withCouponRates(fixedRate, fixedLegDayCounter)
.withNotionals(nominals)
.withPaymentAdjustment(index.businessDayConvention());
Swap swap = new Swap(floatingLeg, fixedLeg);
swap.setPricingEngine(new DiscountingSwapEngine(termStructure));
double bp = 1.0e-4;
double fairRate = fixedRate - (double)(swap.NPV()/(swap.legBPS(1) / bp));
List<double> exerciceRate = new InitializedList<double>(1,fairRate);
cap_ = new Cap(floatingLeg, exerciceRate);
marketValue_ = blackPrice(volatility_.link.value());
}
public CapHelper(Period length,
Handle <Quote> volatility,
IborIndex index,
// data for ATM swap-rate calculation
Frequency fixedLegFrequency,
DayCounter fixedLegDayCounter,
bool includeFirstSwaplet,
Handle <YieldTermStructure> termStructure,
bool calibrateVolatility /*= false*/)
: base(volatility, termStructure, calibrateVolatility)
{
Period indexTenor = index.tenor();
double fixedRate = 0.04; // dummy value
Date startDate, maturity;
if (includeFirstSwaplet)
{
startDate = termStructure.link.referenceDate();
maturity = termStructure.link.referenceDate() + length;
}
else
{
startDate = termStructure.link.referenceDate() + indexTenor;
maturity = termStructure.link.referenceDate() + length;
}
IborIndex dummyIndex = new
IborIndex("dummy",
indexTenor,
index.fixingDays(),
index.currency(),
index.fixingCalendar(),
index.businessDayConvention(),
index.endOfMonth(),
termStructure.link.dayCounter(),
termStructure);
List <double> nominals = new InitializedList <double>(1, 1.0);
Schedule floatSchedule = new Schedule(startDate, maturity,
index.tenor(), index.fixingCalendar(),
index.businessDayConvention(),
index.businessDayConvention(),
DateGeneration.Rule.Forward, false);
List <CashFlow> floatingLeg;
IborLeg iborLeg = (IborLeg) new IborLeg(floatSchedule, index)
.withFixingDays(0)
.withNotionals(nominals)
.withPaymentAdjustment(index.businessDayConvention());
floatingLeg = iborLeg.value();
Schedule fixedSchedule = new Schedule(startDate, maturity, new Period(fixedLegFrequency),
index.fixingCalendar(),
BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
DateGeneration.Rule.Forward, false);
List <CashFlow> fixedLeg = new FixedRateLeg(fixedSchedule)
.withCouponRates(fixedRate, fixedLegDayCounter)
.withNotionals(nominals)
.withPaymentAdjustment(index.businessDayConvention());
Swap swap = new Swap(floatingLeg, fixedLeg);
swap.setPricingEngine(new DiscountingSwapEngine(termStructure));
double bp = 1.0e-4;
double fairRate = fixedRate - (double)(swap.NPV() / (swap.legBPS(1) / bp));
List <double> exerciceRate = new InitializedList <double>(1, fairRate);
cap_ = new Cap(floatingLeg, exerciceRate);
marketValue_ = blackPrice(volatility_.link.value());
}
