public AmortizingFixedRateBond(
int settlementDays,
Calendar calendar,
double faceAmount,
Date startDate,
Period bondTenor,
Frequency sinkingFrequency,
double coupon,
DayCounter accrualDayCounter,
BusinessDayConvention paymentConvention = BusinessDayConvention.Following,
Date issueDate = null)
: base(settlementDays, calendar, issueDate)
{
frequency_ = sinkingFrequency;
dayCounter_ = accrualDayCounter;
Utils.QL_REQUIRE(bondTenor.length() > 0, () =>
"bond tenor must be positive. "
+ bondTenor + " is not allowed.");
maturityDate_ = startDate + bondTenor;
schedule_ = sinkingSchedule(startDate, bondTenor, sinkingFrequency, calendar);
cashflows_ = new FixedRateLeg(schedule_)
.withCouponRates(coupon, accrualDayCounter)
.withNotionals(sinkingNotionals(bondTenor, sinkingFrequency, coupon, faceAmount))
.withPaymentAdjustment(paymentConvention).value();
addRedemptionsToCashflows();
}
protected void checkRange(Date optionDate, Period bondTenor, double k, bool extrapolate)
{
base.checkRange(timeFromReference(optionDate),
extrapolate);
Utils.QL_REQUIRE(bondTenor.length() > 0, () =>
"negative bond tenor (" + bondTenor + ") given");
Utils.QL_REQUIRE(extrapolate || allowsExtrapolation() ||
bondTenor <= maxBondTenor(), () =>
"bond tenor (" + bondTenor + ") is past max tenor ("
+ maxBondTenor() + ")");
Utils.QL_REQUIRE(extrapolate || allowsExtrapolation() ||
(k >= minStrike() && k <= maxStrike()), () =>
"strike (" + k + ") is outside the curve domain ["
+ minStrike() + "," + maxStrike() + "]");
}
KeyValuePair <int, int> daysMinMax(Period p)
{
switch (p.units())
{
case TimeUnit.Days:
return(new KeyValuePair <int, int>(p.length(), p.length()));
case TimeUnit.Weeks:
return(new KeyValuePair <int, int>(7 * p.length(), 7 * p.length()));
case TimeUnit.Months:
return(new KeyValuePair <int, int>(28 * p.length(), 31 * p.length()));
case TimeUnit.Years:
return(new KeyValuePair <int, int>(365 * p.length(), 366 * p.length()));
default:
Utils.QL_FAIL("unknown time unit (" + p.units() + ")");
return(new KeyValuePair <int, int>());
}
}
public pair(Period p)
{
switch (p.units())
{
case TimeUnit.Days:
lo = hi = p.length(); break;
case TimeUnit.Weeks:
lo = hi = 7 * p.length(); break;
case TimeUnit.Months:
lo = 28 * p.length(); hi = 31 * p.length(); break;
case TimeUnit.Years:
lo = 365 * p.length(); hi = 366 * p.length(); break;
default:
Utils.QL_FAIL("Unknown TimeUnit: " + p.units());
lo = hi = 0;
break;
}
}
/// <summary>
/// rule based constructor
/// </summary>
/// <param name="effectiveDate"></param>
/// <param name="terminationDate"></param>
/// <param name="tenor"></param>
/// <param name="calendar"></param>
/// <param name="convention"></param>
/// <param name="terminationDateConvention"></param>
/// <param name="rule"></param>
/// <param name="endOfMonth"></param>
/// <param name="firstDate"></param>
/// <param name="nextToLastDate"></param>
public Schedule(Date effectiveDate,
Date terminationDate,
Period tenor,
Calendar calendar,
BusinessDayConvention convention,
BusinessDayConvention terminationDateConvention,
DateGeneration.Rule rule,
bool endOfMonth,
Date firstDate = null,
Date nextToLastDate = null)
{
calendar_ = calendar ?? new NullCalendar();
firstDate_ = firstDate == effectiveDate ? null : firstDate;
nextToLastDate_ = nextToLastDate == terminationDate ? null : nextToLastDate;
tenor_ = tenor;
convention_ = convention;
terminationDateConvention_ = terminationDateConvention;
rule_ = rule;
endOfMonth_ = allowsEndOfMonth(tenor) && endOfMonth;
// sanity checks
Utils.QL_REQUIRE(terminationDate != null, () => "null termination date");
// in many cases (e.g. non-expired bonds) the effective date is not
// really necessary. In these cases a decent placeholder is enough
if (effectiveDate == null && firstDate == null && rule == DateGeneration.Rule.Backward)
{
Date evalDate = Settings.Instance.evaluationDate();
Utils.QL_REQUIRE(evalDate < terminationDate, () => "null effective date", QLNetExceptionEnum.NullEffectiveDate);
int y;
if (nextToLastDate != null)
{
y = (nextToLastDate - evalDate) / 366 + 1;
effectiveDate = nextToLastDate - new Period(y, TimeUnit.Years);
}
else
{
y = (terminationDate - evalDate) / 366 + 1;
effectiveDate = terminationDate - new Period(y, TimeUnit.Years);
}
// More accurate , is the previous coupon date
if (effectiveDate > evalDate)
{
effectiveDate = effectiveDate - new Period(tenor_.length(), TimeUnit.Months);
}
else if (effectiveDate + new Period(tenor_.length(), TimeUnit.Months) < evalDate)
{
effectiveDate = effectiveDate + new Period(tenor_.length(), TimeUnit.Months);
}
}
else
{
Utils.QL_REQUIRE(effectiveDate != null, () => "null effective date", QLNetExceptionEnum.NullEffectiveDate);
}
Utils.QL_REQUIRE(effectiveDate < terminationDate, () =>
"effective date (" + effectiveDate +
") later than or equal to termination date (" +
terminationDate + ")"
);
if (tenor_.length() == 0)
{
rule_ = DateGeneration.Rule.Zero;
}
else
{
Utils.QL_REQUIRE(tenor.length() > 0, () => "non positive tenor (" + tenor + ") not allowed");
}
if (firstDate_ != null)
{
switch (rule_.Value)
{
case DateGeneration.Rule.Backward:
case DateGeneration.Rule.Forward:
Utils.QL_REQUIRE(firstDate_ > effectiveDate &&
firstDate_ < terminationDate, () =>
"first date (" + firstDate_ + ") out of effective-termination date range [" +
effectiveDate + ", " + terminationDate + ")");
// we should ensure that the above condition is still verified after adjustment
break;
case DateGeneration.Rule.ThirdWednesday:
Utils.QL_REQUIRE(IMM.isIMMdate(firstDate_, false), () => "first date (" + firstDate_ + ") is not an IMM date");
break;
case DateGeneration.Rule.Zero:
case DateGeneration.Rule.Twentieth:
case DateGeneration.Rule.TwentiethIMM:
case DateGeneration.Rule.OldCDS:
case DateGeneration.Rule.CDS:
case DateGeneration.Rule.CDS2015:
Utils.QL_FAIL("first date incompatible with " + rule_.Value + " date generation rule");
break;
default:
Utils.QL_FAIL("unknown rule (" + rule_.Value + ")");
break;
}
}
if (nextToLastDate_ != null)
{
switch (rule_.Value)
{
case DateGeneration.Rule.Backward:
case DateGeneration.Rule.Forward:
Utils.QL_REQUIRE(nextToLastDate_ > effectiveDate && nextToLastDate_ < terminationDate, () =>
"next to last date (" + nextToLastDate_ + ") out of effective-termination date range (" +
effectiveDate + ", " + terminationDate + "]");
// we should ensure that the above condition is still verified after adjustment
break;
case DateGeneration.Rule.ThirdWednesday:
Utils.QL_REQUIRE(IMM.isIMMdate(nextToLastDate_, false), () => "next-to-last date (" + nextToLastDate_ +
") is not an IMM date");
break;
case DateGeneration.Rule.Zero:
case DateGeneration.Rule.Twentieth:
case DateGeneration.Rule.TwentiethIMM:
case DateGeneration.Rule.OldCDS:
case DateGeneration.Rule.CDS:
case DateGeneration.Rule.CDS2015:
Utils.QL_FAIL("next to last date incompatible with " + rule_.Value + " date generation rule");
break;
default:
Utils.QL_FAIL("unknown rule (" + rule_.Value + ")");
break;
}
}
// calendar needed for endOfMonth adjustment
Calendar nullCalendar = new NullCalendar();
int periods = 1;
Date seed = new Date(), exitDate = new Date();
switch (rule_.Value)
{
case DateGeneration.Rule.Zero:
tenor_ = new Period(0, TimeUnit.Years);
dates_.Add(effectiveDate);
dates_.Add(terminationDate);
isRegular_.Add(true);
break;
case DateGeneration.Rule.Backward:
dates_.Add(terminationDate);
seed = terminationDate;
if (nextToLastDate_ != null)
{
dates_.Insert(0, nextToLastDate_);
Date temp = nullCalendar.advance(seed, -periods * tenor_, convention_, endOfMonth_.Value);
if (temp != nextToLastDate_)
{
isRegular_.Insert(0, false);
}
else
{
isRegular_.Insert(0, true);
}
seed = nextToLastDate_;
}
exitDate = effectiveDate;
if (firstDate_ != null)
{
exitDate = firstDate_;
}
while (true)
{
Date temp = nullCalendar.advance(seed, -periods * tenor_, convention_, endOfMonth_.Value);
if (temp < exitDate)
{
if (firstDate_ != null && (calendar_.adjust(dates_.First(), convention_) !=
calendar_.adjust(firstDate_, convention_)))
{
dates_.Insert(0, firstDate_);
isRegular_.Insert(0, false);
}
break;
}
else
{
// skip dates that would result in duplicates
// after adjustment
if (calendar_.adjust(dates_.First(), convention_) != calendar_.adjust(temp, convention_))
{
dates_.Insert(0, temp);
isRegular_.Insert(0, true);
}
++periods;
}
}
if (calendar_.adjust(dates_.First(), convention) != calendar_.adjust(effectiveDate, convention))
{
dates_.Insert(0, effectiveDate);
isRegular_.Insert(0, false);
}
break;
case DateGeneration.Rule.Twentieth:
case DateGeneration.Rule.TwentiethIMM:
case DateGeneration.Rule.ThirdWednesday:
case DateGeneration.Rule.OldCDS:
case DateGeneration.Rule.CDS:
case DateGeneration.Rule.CDS2015:
Utils.QL_REQUIRE(!endOfMonth, () => "endOfMonth convention incompatible with " + rule_.Value + " date generation rule");
goto case DateGeneration.Rule.Forward; // fall through
case DateGeneration.Rule.Forward:
if (rule_.Value == DateGeneration.Rule.CDS ||
rule_.Value == DateGeneration.Rule.CDS2015)
{
dates_.Add(previousTwentieth(effectiveDate, rule_.Value));
}
else
{
dates_.Add(effectiveDate);
}
seed = dates_.Last();
if (firstDate_ != null)
{
dates_.Add(firstDate_);
Date temp = nullCalendar.advance(seed, periods * tenor_, convention_, endOfMonth_.Value);
if (temp != firstDate_)
{
isRegular_.Add(false);
}
else
{
isRegular_.Add(true);
}
seed = firstDate_;
}
else if (rule_.Value == DateGeneration.Rule.Twentieth ||
rule_.Value == DateGeneration.Rule.TwentiethIMM ||
rule_.Value == DateGeneration.Rule.OldCDS ||
rule_.Value == DateGeneration.Rule.CDS ||
rule_.Value == DateGeneration.Rule.CDS2015)
{
Date next20th = nextTwentieth(effectiveDate, rule_.Value);
if (rule_ == DateGeneration.Rule.OldCDS)
{
// distance rule inforced in natural days
long stubDays = 30;
if (next20th - effectiveDate < stubDays)
{
// +1 will skip this one and get the next
next20th = nextTwentieth(next20th + 1, rule_.Value);
}
}
if (next20th != effectiveDate)
{
dates_.Add(next20th);
isRegular_.Add(false);
seed = next20th;
}
}
exitDate = terminationDate;
if (nextToLastDate_ != null)
{
exitDate = nextToLastDate_;
}
if (rule_ == DateGeneration.Rule.CDS2015 &&
nextTwentieth(terminationDate, rule_.Value) == terminationDate &&
terminationDate.month() % 2 == 1)
{
exitDate = nextTwentieth(terminationDate + 1, rule_.Value);
}
while (true)
{
Date temp = nullCalendar.advance(seed, periods * tenor_, convention_, endOfMonth_.Value);
if (temp > exitDate)
{
if (nextToLastDate_ != null &&
(calendar_.adjust(dates_.Last(), convention_) != calendar_.adjust(nextToLastDate_, convention_)))
{
dates_.Add(nextToLastDate_);
isRegular_.Add(false);
}
break;
}
else
{
// skip dates that would result in duplicates
// after adjustment
if (calendar_.adjust(dates_.Last(), convention_) != calendar_.adjust(temp, convention_))
{
dates_.Add(temp);
isRegular_.Add(true);
}
++periods;
}
}
if (calendar_.adjust(dates_.Last(), terminationDateConvention_.Value) !=
calendar_.adjust(terminationDate, terminationDateConvention_.Value))
{
if (rule_.Value == DateGeneration.Rule.Twentieth ||
rule_.Value == DateGeneration.Rule.TwentiethIMM ||
rule_.Value == DateGeneration.Rule.OldCDS ||
rule_.Value == DateGeneration.Rule.CDS)
{
dates_.Add(nextTwentieth(terminationDate, rule_.Value));
isRegular_.Add(true);
}
else if (rule_ == DateGeneration.Rule.CDS2015)
{
Date tentativeTerminationDate = nextTwentieth(terminationDate, rule_.Value);
if (tentativeTerminationDate.month() % 2 == 0)
{
dates_.Add(tentativeTerminationDate);
isRegular_.Add(true);
}
}
else
{
dates_.Add(terminationDate);
isRegular_.Add(false);
}
}
break;
default:
Utils.QL_FAIL("unknown rule (" + rule_.Value + ")");
break;
}
// adjustments
if (rule_ == DateGeneration.Rule.ThirdWednesday)
{
for (int i = 1; i < dates_.Count - 1; ++i)
{
dates_[i] = Date.nthWeekday(3, DayOfWeek.Wednesday, dates_[i].Month, dates_[i].Year);
}
}
if (endOfMonth && calendar_.isEndOfMonth(seed))
{
// adjust to end of month
if (convention_ == BusinessDayConvention.Unadjusted)
{
for (int i = 1; i < dates_.Count - 1; ++i)
{
dates_[i] = Date.endOfMonth(dates_[i]);
}
}
else
{
for (int i = 1; i < dates_.Count - 1; ++i)
{
dates_[i] = calendar_.endOfMonth(dates_[i]);
}
}
if (terminationDateConvention_ != BusinessDayConvention.Unadjusted)
{
dates_[0] = calendar_.endOfMonth(dates_.First());
dates_[dates_.Count - 1] = calendar_.endOfMonth(dates_.Last());
}
else
{
// the termination date is the first if going backwards,
// the last otherwise.
if (rule_ == DateGeneration.Rule.Backward)
{
dates_[dates_.Count - 1] = Date.endOfMonth(dates_.Last());
}
else
{
dates_[0] = Date.endOfMonth(dates_.First());
}
}
}
else
{
// first date not adjusted for CDS schedules
if (rule_ != DateGeneration.Rule.OldCDS)
{
dates_[0] = calendar_.adjust(dates_[0], convention_);
}
for (int i = 1; i < dates_.Count - 1; ++i)
{
dates_[i] = calendar_.adjust(dates_[i], convention_);
}
// termination date is NOT adjusted as per ISDA specifications, unless otherwise specified in the
// confirmation of the deal or unless we're creating a CDS schedule
if (terminationDateConvention_.Value != BusinessDayConvention.Unadjusted &&
rule_.Value != DateGeneration.Rule.CDS &&
rule_.Value != DateGeneration.Rule.CDS2015)
{
dates_[dates_.Count - 1] = calendar_.adjust(dates_.Last(), terminationDateConvention_.Value);
}
}
// Final safety checks to remove extra next-to-last date, if
// necessary. It can happen to be equal or later than the end
// date due to EOM adjustments (see the Schedule test suite
// for an example).
if (dates_.Count >= 2 && dates_[dates_.Count - 2] >= dates_.Last())
{
isRegular_[isRegular_.Count - 2] = (dates_[dates_.Count - 2] == dates_.Last());
dates_[dates_.Count - 2] = dates_.Last();
dates_.RemoveAt(dates_.Count - 1);
isRegular_.RemoveAt(isRegular_.Count - 1);
}
if (dates_.Count >= 2 && dates_[1] <= dates_.First())
{
isRegular_[1] = (dates_[1] == dates_.First());
dates_[1] = dates_.First();
dates_.RemoveAt(0);
isRegular_.RemoveAt(0);
}
Utils.QL_REQUIRE(dates_.Count > 1,
() => "degenerate single date (" + dates_[0] + ") schedule" +
"\n seed date: " + seed +
"\n exit date: " + exitDate +
"\n effective date: " + effectiveDate +
"\n first date: " + firstDate +
"\n next to last date: " + nextToLastDate +
"\n termination date: " + terminationDate +
"\n generation rule: " + rule_.Value +
"\n end of month: " + endOfMonth_.Value);
}
//! The factor returned is NOT normalized relative to ANYTHING.
public virtual double seasonalityFactor(Date to)
{
Date from = seasonalityBaseDate();
Frequency factorFrequency = frequency();
int nFactors = seasonalityFactors().Count;
Period factorPeriod = new Period(factorFrequency);
int which = 0;
if (from == to)
{
which = 0;
}
else
{
// days, weeks, months, years are the only time unit possibilities
int diffDays = Math.Abs(to - from); // in days
int dir = 1;
if (from > to)
{
dir = -1;
}
int diff = 0;
if (factorPeriod.units() == TimeUnit.Days)
{
diff = dir * diffDays;
}
else if (factorPeriod.units() == TimeUnit.Weeks)
{
diff = dir * (diffDays / 7);
}
else if (factorPeriod.units() == TimeUnit.Months)
{
KeyValuePair <Date, Date> lim = Utils.inflationPeriod(to, factorFrequency);
diff = diffDays / (31 * factorPeriod.length());
Date go = from + dir * diff * factorPeriod;
while (!(lim.Key <= go && go <= lim.Value))
{
go += dir * factorPeriod;
diff++;
}
diff = dir * diff;
}
else if (factorPeriod.units() == TimeUnit.Years)
{
Utils.QL_FAIL("seasonality period time unit is not allowed to be : " + factorPeriod.units());
}
else
{
Utils.QL_FAIL("Unknown time unit: " + factorPeriod.units());
}
// now adjust to the available number of factors, direction dependent
if (dir == 1)
{
which = diff % nFactors;
}
else
{
which = (nFactors - (-diff % nFactors)) % nFactors;
}
}
return(seasonalityFactors()[which]);
}
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);
}
//! set up the interpolations for capPrice_ and floorPrice_
//! since we know ATM, and we have single flows,
//! we can use put/call parity to extend the surfaces
//! across all strikes
protected override void performCalculations()
{
allStrikes_ = new List <double>();
int nMat = cfMaturities_.Count,
ncK = cStrikes_.Count,
nfK = fStrikes_.Count,
nK = ncK + nfK;
Matrix cP = new Matrix(nK, nMat),
fP = new Matrix(nK, nMat);
Handle <ZeroInflationTermStructure> zts = zii_.link.zeroInflationTermStructure();
Handle <YieldTermStructure> yts = this.nominalTermStructure();
Utils.QL_REQUIRE(!zts.empty(), () => "Zts is empty!!!");
Utils.QL_REQUIRE(!yts.empty(), () => "Yts is empty!!!");
for (int i = 0; i < nfK; i++)
{
allStrikes_.Add(fStrikes_[i]);
for (int j = 0; j < nMat; j++)
{
Period mat = cfMaturities_[j];
double df = yts.link.discount(cpiOptionDateFromTenor(mat));
double atm_quote = zts.link.zeroRate(cpiOptionDateFromTenor(mat));
double atm = Math.Pow(1.0 + atm_quote, mat.length());
double S = atm * df;
double K_quote = fStrikes_[i] / 100.0;
double K = Math.Pow(1.0 + K_quote, mat.length());
cP[i, j] = fPrice_[i, j] + S - K * df;
fP[i, j] = fPrice_[i, j];
}
}
for (int i = 0; i < ncK; i++)
{
allStrikes_.Add(cStrikes_[i]);
for (int j = 0; j < nMat; j++)
{
Period mat = cfMaturities_[j];
double df = yts.link.discount(cpiOptionDateFromTenor(mat));
double atm_quote = zts.link.zeroRate(cpiOptionDateFromTenor(mat));
double atm = Math.Pow(1.0 + atm_quote, mat.length());
double S = atm * df;
double K_quote = cStrikes_[i] / 100.0;
double K = Math.Pow(1.0 + K_quote, mat.length());
cP[i + nfK, j] = cPrice_[i, j];
fP[i + nfK, j] = cPrice_[i, j] + K * df - S;
}
}
// copy to store
cPriceB_ = cP;
fPriceB_ = fP;
cfMaturityTimes_ = new List <double>();
for (int i = 0; i < cfMaturities_.Count; i++)
{
cfMaturityTimes_.Add(timeFromReference(cpiOptionDateFromTenor(cfMaturities_[i])));
}
capPrice_ = interpolator2d_.interpolate(cfMaturityTimes_, cfMaturityTimes_.Count,
allStrikes_, allStrikes_.Count, cPriceB_);
capPrice_.enableExtrapolation();
floorPrice_ = interpolator2d_.interpolate(cfMaturityTimes_, cfMaturityTimes_.Count,
allStrikes_, allStrikes_.Count, fPriceB_);
floorPrice_.enableExtrapolation();
}
/// <summary>
/// Advances the given date as specified by the given period and
/// returns the result.
/// </summary>
/// <remarks>The input date is not modified.</remarks>
public Date advance(Date d, Period p, BusinessDayConvention c = BusinessDayConvention.Following, bool endOfMonth = false)
{
return(advance(d, p.length(), p.units(), c, endOfMonth));
}